import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
import type { IBinaryWriter } from '@protobuf-ts/runtime';
import type { BinaryReadOptions } from '@protobuf-ts/runtime';
import type { IBinaryReader } from '@protobuf-ts/runtime';
import type { PartialMessage } from '@protobuf-ts/runtime';
import { MessageType } from '@protobuf-ts/runtime';
import { Signature } from '../../crypto/v30/crypto.js';
import { DynamicSequencingParameters } from './sequencing_parameters.js';
import { DynamicSynchronizerParameters } from './synchronizer_parameters.js';
import { Timestamp } from '../../../../../google/protobuf/timestamp.js';
import { ParticipantSynchronizerLimits } from './synchronizer_parameters.js';
import { PublicKey } from '../../crypto/v30/crypto.js';
import { SigningPublicKey } from '../../crypto/v30/crypto.js';
/**
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.Enums
 */
export interface Enums {
}
/**
 * @generated from protobuf enum com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp
 */
export declare enum Enums_TopologyChangeOp {
    /**
     * @generated from protobuf enum value: TOPOLOGY_CHANGE_OP_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * Adds a new or replaces an existing mapping
     *
     * @generated from protobuf enum value: TOPOLOGY_CHANGE_OP_ADD_REPLACE = 1;
     */
    ADD_REPLACE = 1,
    /**
     * Remove an existing mapping
     *
     * @generated from protobuf enum value: TOPOLOGY_CHANGE_OP_REMOVE = 2;
     */
    REMOVE = 2
}
/**
 * enum indicating the participant permission level
 * Regardless of the ParticipantPermission level, all participants can submit a reassignment.
 *
 * @generated from protobuf enum com.digitalasset.canton.protocol.v30.Enums.ParticipantPermission
 */
export declare enum Enums_ParticipantPermission {
    /**
     * @generated from protobuf enum value: PARTICIPANT_PERMISSION_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * participant is active, can submit transactions and reassignments
     *
     * @generated from protobuf enum value: PARTICIPANT_PERMISSION_SUBMISSION = 1;
     */
    SUBMISSION = 1,
    /**
     * participant is passive, can only confirm transactions and submit reassignments
     *
     * @generated from protobuf enum value: PARTICIPANT_PERMISSION_CONFIRMATION = 2;
     */
    CONFIRMATION = 2,
    /**
     * participant is passive, can only observe transactions and submit reassignments
     *
     * @generated from protobuf enum value: PARTICIPANT_PERMISSION_OBSERVATION = 3;
     */
    OBSERVATION = 3
}
/**
 * @generated from protobuf enum com.digitalasset.canton.protocol.v30.Enums.TopologyMappingCode
 */
export declare enum Enums_TopologyMappingCode {
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_UNSPECIFIED = 0;
     */
    UNSPECIFIED = 0,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_NAMESPACE_DELEGATION = 1;
     */
    NAMESPACE_DELEGATION = 1,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_DECENTRALIZED_NAMESPACE_DEFINITION = 3;
     */
    DECENTRALIZED_NAMESPACE_DEFINITION = 3,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_OWNER_TO_KEY_MAPPING = 4;
     */
    OWNER_TO_KEY_MAPPING = 4,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_SYNCHRONIZER_TRUST_CERTIFICATE = 5;
     */
    SYNCHRONIZER_TRUST_CERTIFICATE = 5,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_PARTICIPANT_PERMISSION = 6;
     */
    PARTICIPANT_PERMISSION = 6,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_PARTY_HOSTING_LIMITS = 7;
     */
    PARTY_HOSTING_LIMITS = 7,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_VETTED_PACKAGES = 8;
     */
    VETTED_PACKAGES = 8,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_PARTY_TO_PARTICIPANT = 9;
     */
    PARTY_TO_PARTICIPANT = 9,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_SYNCHRONIZER_PARAMETERS_STATE = 11;
     */
    SYNCHRONIZER_PARAMETERS_STATE = 11,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_MEDIATOR_SYNCHRONIZER_STATE = 12;
     */
    MEDIATOR_SYNCHRONIZER_STATE = 12,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_SEQUENCER_SYNCHRONIZER_STATE = 13;
     */
    SEQUENCER_SYNCHRONIZER_STATE = 13,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_PURGE_TOPOLOGY_TXS = 15;
     */
    PURGE_TOPOLOGY_TXS = 15,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_SEQUENCING_DYNAMIC_PARAMETERS_STATE = 17;
     */
    SEQUENCING_DYNAMIC_PARAMETERS_STATE = 17,
    /**
     * @generated from protobuf enum value: TOPOLOGY_MAPPING_CODE_PARTY_TO_KEY_MAPPING = 18;
     */
    PARTY_TO_KEY_MAPPING = 18
}
/**
 * [start NamespaceDelegation definition]
 * namespace delegation (equivalent to X509v3 CA root or intermediate CAs)
 * if is_root_delegation==false, the target key may sign all mappings requiring a signature
 * for the namespace except other NamespaceDelegation mappings.
 * authorization: a namespace delegation is either signed by the root key, or is signed by
 *   a key for which there exists a series of properly authorized namespace delegations
 *   that are ultimately signed by the root key
 * UNIQUE(namespace, target_key)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation
 */
export interface NamespaceDelegation {
    /**
     * fingerprint of the root key defining the namespace
     *
     * @generated from protobuf field: string namespace = 1
     */
    namespace: string;
    /**
     * target key of getting full rights on the namespace (if target == namespace, it's a root CA)
     *
     * @generated from protobuf field: com.digitalasset.canton.crypto.v30.SigningPublicKey target_key = 2
     */
    targetKey?: SigningPublicKey;
    /**
     * flag indicating whether the given delegation is a root delegation or not
     * a root delegation is also allowed to issue other NamespaceDelegations.
     *
     * @deprecated
     * @generated from protobuf field: bool is_root_delegation = 3 [deprecated = true]
     */
    isRootDelegation: boolean;
    /**
     * restricts target_key to only sign transactions with the specified mapping types.
     * for backwards compatibility, only the following combinations are valid:
     * * is_root_delegation = true,  restriction = empty: the key can sign all mappings
     * * is_root_delegation = false, restriction = empty: the key can sign all mappings but namespace delegations
     * * is_root_delegation = false, restriction = non-empty: the key can only sign the mappings according the restriction that is set
     *
     * @generated from protobuf oneof: restriction
     */
    restriction: {
        oneofKind: 'canSignAllMappings';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignAllMappings can_sign_all_mappings = 4
         */
        canSignAllMappings: NamespaceDelegation_CanSignAllMappings;
    } | {
        oneofKind: 'canSignAllButNamespaceDelegations';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignAllButNamespaceDelegations can_sign_all_but_namespace_delegations = 5
         */
        canSignAllButNamespaceDelegations: NamespaceDelegation_CanSignAllButNamespaceDelegations;
    } | {
        oneofKind: 'canSignSpecificMapings';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignSpecificMappings can_sign_specific_mapings = 6
         */
        canSignSpecificMapings: NamespaceDelegation_CanSignSpecificMappings;
    } | {
        oneofKind: undefined;
    };
}
/**
 * [start-docs-entry: namespace delegation restrictions]
 * the key can sign all currently known mappings and all mappings that will be added in future releases
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignAllMappings
 */
export interface NamespaceDelegation_CanSignAllMappings {
}
/**
 * the key can sign all currently known mappings and all mappings that will be added in future releases, except for
 * namespace delegations
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignAllButNamespaceDelegations
 */
export interface NamespaceDelegation_CanSignAllButNamespaceDelegations {
}
/**
 * the key can only sign the explicitly specified mappings
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignSpecificMappings
 */
export interface NamespaceDelegation_CanSignSpecificMappings {
    /**
     * @generated from protobuf field: repeated com.digitalasset.canton.protocol.v30.Enums.TopologyMappingCode mappings = 1
     */
    mappings: Enums_TopologyMappingCode[];
}
/**
 * a decentralized namespace definition that creates a new namespace supported by the
 * the original owners
 * authorization: the decentralized namespace definition with serial = 1 must be authorized by all the
 *   owners of the namespace that form the decentralized namespace.
 *   for definitions with serial > 1, we need the authorization of #threshold owners plus
 *   all new owners
 *
 *   any further transaction within the decentralized namespace other than decentralized namespace definitions needs
 *   #threshold signatures of the owners
 *
 * UNIQUE(decentralized_namespace)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.DecentralizedNamespaceDefinition
 */
export interface DecentralizedNamespaceDefinition {
    /**
     * name of the decentralized namespace, computed from the hash of its initial owners
     *
     * @generated from protobuf field: string decentralized_namespace = 1
     */
    decentralizedNamespace: string;
    /**
     * the threshold required for any subsequent update signing
     *
     * @generated from protobuf field: int32 threshold = 2
     */
    threshold: number;
    /**
     * the namespaces of the owners
     *
     * @generated from protobuf field: repeated string owners = 3
     */
    owners: string[];
}
/**
 * mapping a member (participant, mediator, sequencer) to a key
 * authorization: whoever controls the member uid
 * UNIQUE(member)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.OwnerToKeyMapping
 */
export interface OwnerToKeyMapping {
    /**
     * the sequencing process member
     *
     * @generated from protobuf field: string member = 1
     */
    member: string;
    /**
     * the designated keys
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.crypto.v30.PublicKey public_keys = 2
     */
    publicKeys: PublicKey[];
}
/**
 * [doc-entry-start: PartyToKeyMapping]
 * mapping a party to a key
 * authorization: whoever controls the party uid
 * UNIQUE(party)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.PartyToKeyMapping
 */
export interface PartyToKeyMapping {
    /**
     * the party
     *
     * @generated from protobuf field: string party = 1
     */
    party: string;
    /**
     * the authorization threshold
     *
     * @generated from protobuf field: uint32 threshold = 3
     */
    threshold: number;
    /**
     * the designated signing keys
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.crypto.v30.SigningPublicKey signing_keys = 4
     */
    signingKeys: SigningPublicKey[];
}
/**
 * the trust certificate issued by the participant confirming that the participant
 * wishes to be present on the given synchronizer
 * authorization: whoever controls the participant uid
 * UNIQUE(participant,synchronizer_id)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.SynchronizerTrustCertificate
 */
export interface SynchronizerTrustCertificate {
    /**
     * the uid of the participant
     *
     * @generated from protobuf field: string participant_uid = 1
     */
    participantUid: string;
    /**
     * the uid of the synchronizer that the participant trusts
     *
     * @generated from protobuf field: string synchronizer_id = 2
     */
    synchronizerId: string;
}
/**
 * the optional trust certificate of the synchronizer towards the participant
 * authorization: whoever controls the synchronizer id
 * UNIQUE(synchronizer_id,participant)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.ParticipantSynchronizerPermission
 */
export interface ParticipantSynchronizerPermission {
    /**
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * @generated from protobuf field: string participant_uid = 2
     */
    participantUid: string;
    /**
     * the permission level of the participant on this synchronizer (usually submission)
     *
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.Enums.ParticipantPermission permission = 3
     */
    permission: Enums_ParticipantPermission;
    /**
     * optional individual limits for this participant
     *
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.ParticipantSynchronizerLimits limits = 4
     */
    limits?: ParticipantSynchronizerLimits;
    /**
     * optional earliest time when participant can log in (again)
     * used to temporarily disable participants
     * In microseconds of UTC time since Unix epoch
     *
     * @generated from protobuf field: optional int64 login_after = 5
     */
    loginAfter?: bigint;
}
/**
 * the optional hosting limits for a party on a given synchronizer
 * these limits can be used to limit the number of participants that can host a given party
 * authorization: whoever controls the synchronizer id
 * UNIQUE(synchronizer_id,party)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.PartyHostingLimits
 */
export interface PartyHostingLimits {
    /**
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * @generated from protobuf field: string party = 2
     */
    party: string;
}
/**
 * list of packages supported by this participant
 * authorization: whoever controls the participant uid
 * UNIQUE(participant)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.VettedPackages
 */
export interface VettedPackages {
    /**
     * the participant vetting the packages
     *
     * @generated from protobuf field: string participant_uid = 1
     */
    participantUid: string;
    /**
     * DEPRECATED: no longer used, but kept for backwards compatibility.
     * the hashes of the vetted packages.
     * package hashes may only be listed in one of the two fields: package_ids or packages.
     * a package listed in package_ids is equivalent to a package listed in packages with unbounded validity.
     *
     * @deprecated
     * @generated from protobuf field: repeated string package_ids = 2 [deprecated = true]
     */
    packageIds: string[];
    /**
     * the hashes of vetted packages with a validity period.
     * only one entry per package_id is permitted.
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.protocol.v30.VettedPackages.VettedPackage packages = 4
     */
    packages: VettedPackages_VettedPackage[];
}
/**
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.VettedPackages.VettedPackage
 */
export interface VettedPackages_VettedPackage {
    /**
     * the hash of the vetted package
     *
     * @generated from protobuf field: string package_id = 1
     */
    packageId: string;
    /**
     * optional earliest ledger effective time (exclusive) as of which the package is considered valid.
     * must be less than or equal to valid_until if both are present.
     *
     * @generated from protobuf field: google.protobuf.Timestamp valid_from = 2
     */
    validFrom?: Timestamp;
    /**
     * optional latest ledger effective time (inclusive) until which the package is considered valid.
     * must be greater than or equal to valid_from if both are present.
     *
     * @generated from protobuf field: google.protobuf.Timestamp valid_until = 3
     */
    validUntil?: Timestamp;
}
/**
 * mapping that maps a party to a participant
 * authorization: whoever controls the party and all the owners of the participants that
 *   were not already present in the tx with serial = n - 1
 *   exception:
 *     - a participant can disassociate itself with the party unilaterally as long there will be
 *       enough participants to reach "threshold" during confirmation. The disassociating participant
 *       must lower the threshold by one, if otherwise the number of hosting participants would go
 *       below the threshold.
 * UNIQUE(party)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.PartyToParticipant
 */
export interface PartyToParticipant {
    /**
     * the party that is to be represented by the participants
     *
     * @generated from protobuf field: string party = 1
     */
    party: string;
    /**
     * the signatory threshold required by the participants to be able to act on behalf of the party.
     * a mapping with threshold > 1 is considered a definition of a consortium party
     *
     * @generated from protobuf field: uint32 threshold = 2
     */
    threshold: number;
    /**
     * which participants will host the party.
     * if threshold > 1, must be Confirmation or Observation
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.protocol.v30.PartyToParticipant.HostingParticipant participants = 3
     */
    participants: PartyToParticipant_HostingParticipant[];
}
/**
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.PartyToParticipant.HostingParticipant
 */
export interface PartyToParticipant_HostingParticipant {
    /**
     * the target participant that the party should be mapped to
     *
     * @generated from protobuf field: string participant_uid = 1
     */
    participantUid: string;
    /**
     * permission of the participant for this particular party (the actual
     * will be min of ParticipantSynchronizerPermission.ParticipantPermission and this setting)
     *
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.Enums.ParticipantPermission permission = 2
     */
    permission: Enums_ParticipantPermission;
}
/**
 * which dynamic synchronizer parameters are supposed to be used on the given synchronizer
 * authorization: whoever controls the synchronizer
 * UNIQUE(synchronizer_id)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.SynchronizerParametersState
 */
export interface SynchronizerParametersState {
    /**
     * synchronizer affected by the new synchronizer parameters
     *
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.DynamicSynchronizerParameters synchronizer_parameters = 2
     */
    synchronizerParameters?: DynamicSynchronizerParameters;
}
/**
 * which sequencing dynamic parameters are supposed to be used on the given synchronizer; defaults are used when not set
 * authorization: whoever controls the synchronizer
 * UNIQUE(synchronizer_id)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.DynamicSequencingParametersState
 */
export interface DynamicSequencingParametersState {
    /**
     * synchronizer affected by the new synchronizer parameters
     *
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.DynamicSequencingParameters sequencing_parameters = 2
     */
    sequencingParameters?: DynamicSequencingParameters;
}
/**
 * which mediators and mediator groups are active on the given synchronizer
 * authorization: whoever controls the synchronizer
 * UNIQUE(synchronizer_id, group)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.MediatorSynchronizerState
 */
export interface MediatorSynchronizerState {
    /**
     * the synchronizer id of the mediator group
     *
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * the group-id used for sharding multiple mediator groups
     *
     * @generated from protobuf field: uint32 group = 2
     */
    group: number;
    /**
     * the signature threshold required to reach consensus among the mediators
     *
     * @generated from protobuf field: uint32 threshold = 3
     */
    threshold: number;
    /**
     * the list of active mediators (uid) within the group
     *
     * @generated from protobuf field: repeated string active = 4
     */
    active: string[];
    /**
     * the list of observing mediators (uid) within the group (read messages but don't respond)
     *
     * @generated from protobuf field: repeated string observers = 5
     */
    observers: string[];
}
/**
 * which sequencers are active on the given synchronizer
 * authorization: whoever controls the synchronizer
 * UNIQUE(synchronizer_id)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.SequencerSynchronizerState
 */
export interface SequencerSynchronizerState {
    /**
     * the synchronizer id of the sequencer group
     *
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * The system can tolerate up to min(threshold - 1, (activeWithSigningKey.size - 1)/3) malicious active sequencers,
     * where activeWithSigningKey is the set of sequencers from active that have an active OwnerToKeyMapping with a signing key.
     * In order to make the system resilient against f malicious active sequencers, you need to:
     * (1) configure threshold := f + 1,
     * (2) possibly add active sequencers such that f <= (activeWithSigningKey.size - 1)/3.
     * (3) possibly register signing keys for active sequencers,
     *
     * @generated from protobuf field: uint32 threshold = 2
     */
    threshold: number;
    /**
     * the list of active sequencers
     * If a sequencer without an active signing key is added to this set, it has no effect on the topology state.
     *
     * @generated from protobuf field: repeated string active = 3
     */
    active: string[];
    /**
     * the list of observing sequencers (uid) within the group (read messages but don't respond)
     *
     * @generated from protobuf field: repeated string observers = 4
     */
    observers: string[];
}
/**
 * explicitly invalidate topology transactions for good
 * this can be used by the synchronizer to offboard participants forcefully or to
 * remove stray topology transactions
 * authorization: whoever controls the synchronizer
 * UNIQUE(synchronizer_id)
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.PurgeTopologyTransaction
 */
export interface PurgeTopologyTransaction {
    /**
     * the synchronizer id
     *
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * the list of mappings to remove from this synchronizer
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.protocol.v30.TopologyMapping mappings = 2
     */
    mappings: TopologyMapping[];
}
/**
 * [docs-entry-start: topology mapping]
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.TopologyMapping
 */
export interface TopologyMapping {
    /**
     * @generated from protobuf oneof: mapping
     */
    mapping: {
        oneofKind: 'namespaceDelegation';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.NamespaceDelegation namespace_delegation = 1
         */
        namespaceDelegation: NamespaceDelegation;
    } | {
        oneofKind: 'decentralizedNamespaceDefinition';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.DecentralizedNamespaceDefinition decentralized_namespace_definition = 3
         */
        decentralizedNamespaceDefinition: DecentralizedNamespaceDefinition;
    } | {
        oneofKind: 'ownerToKeyMapping';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.OwnerToKeyMapping owner_to_key_mapping = 4
         */
        ownerToKeyMapping: OwnerToKeyMapping;
    } | {
        oneofKind: 'synchronizerTrustCertificate';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.SynchronizerTrustCertificate synchronizer_trust_certificate = 5
         */
        synchronizerTrustCertificate: SynchronizerTrustCertificate;
    } | {
        oneofKind: 'participantPermission';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.ParticipantSynchronizerPermission participant_permission = 6
         */
        participantPermission: ParticipantSynchronizerPermission;
    } | {
        oneofKind: 'partyHostingLimits';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.PartyHostingLimits party_hosting_limits = 7
         */
        partyHostingLimits: PartyHostingLimits;
    } | {
        oneofKind: 'vettedPackages';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.VettedPackages vetted_packages = 8
         */
        vettedPackages: VettedPackages;
    } | {
        oneofKind: 'partyToParticipant';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.PartyToParticipant party_to_participant = 9
         */
        partyToParticipant: PartyToParticipant;
    } | {
        oneofKind: 'synchronizerParametersState';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.SynchronizerParametersState synchronizer_parameters_state = 11
         */
        synchronizerParametersState: SynchronizerParametersState;
    } | {
        oneofKind: 'mediatorSynchronizerState';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.MediatorSynchronizerState mediator_synchronizer_state = 12
         */
        mediatorSynchronizerState: MediatorSynchronizerState;
    } | {
        oneofKind: 'sequencerSynchronizerState';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.SequencerSynchronizerState sequencer_synchronizer_state = 13
         */
        sequencerSynchronizerState: SequencerSynchronizerState;
    } | {
        oneofKind: 'purgeTopologyTxs';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.PurgeTopologyTransaction purge_topology_txs = 14
         */
        purgeTopologyTxs: PurgeTopologyTransaction;
    } | {
        oneofKind: 'sequencingDynamicParametersState';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.DynamicSequencingParametersState sequencing_dynamic_parameters_state = 15
         */
        sequencingDynamicParametersState: DynamicSequencingParametersState;
    } | {
        oneofKind: 'partyToKeyMapping';
        /**
         * @generated from protobuf field: com.digitalasset.canton.protocol.v30.PartyToKeyMapping party_to_key_mapping = 16
         */
        partyToKeyMapping: PartyToKeyMapping;
    } | {
        oneofKind: undefined;
    };
}
/**
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.TopologyTransaction
 */
export interface TopologyTransaction {
    /**
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.Enums.TopologyChangeOp operation = 1
     */
    operation: Enums_TopologyChangeOp;
    /**
     * Serial identifier of this transaction used to prevent replay attacks.
     * A topology transaction is replacing the existing transaction with serial - 1
     * that has the same unique key.
     *
     * @generated from protobuf field: uint32 serial = 2
     */
    serial: number;
    /**
     * the element of this topology transaction
     *
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.TopologyMapping mapping = 3
     */
    mapping?: TopologyMapping;
}
/**
 * Used in SignedTopologyTransaction to bundle together multiple transaction hashes
 * Allows submitters to only sign a single combined hash to authorize multiple transactions at once
 * The combined hash is computed from the transaction hashes
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.MultiTransactionSignatures
 */
export interface MultiTransactionSignatures {
    /**
     * List of topology transaction hashes.
     * Required
     *
     * @generated from protobuf field: repeated bytes transaction_hashes = 1
     */
    transactionHashes: Uint8Array[];
    /**
     * Signatures on the combined hash computed over the transaction_hashes
     * MUST contain at least one
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.crypto.v30.Signature signatures = 2
     */
    signatures: Signature[];
}
/**
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.SignedTopologyTransaction
 */
export interface SignedTopologyTransaction {
    /**
     * serialized topology transaction (protobuf bytestring)
     *
     * @generated from protobuf field: bytes transaction = 1
     */
    transaction: Uint8Array;
    /**
     * multiple signatures
     * Either this field OR the multi_transaction_signatures field MUST contain at least one signature
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.crypto.v30.Signature signatures = 2
     */
    signatures: Signature[];
    /**
     * if true, this transaction is just a proposal. this means that every signature is valid,
     * but the signatures are insufficient to properly authorize the transaction.
     * proposals are distributed via the topology channel too. proposals will be pruned automatically
     * when the nodes are pruned
     * TODO(#14045) implement pruning
     *
     * @generated from protobuf field: bool proposal = 3
     */
    proposal: boolean;
    /**
     * If set, the transaction may be authorized by signing a hash computed from multiple transaction hashes
     * This allows to effectively authorize multiple transactions with a single signature.
     * Each item MUST contain the hash of this transaction
     * Optional
     *
     * @generated from protobuf field: repeated com.digitalasset.canton.protocol.v30.MultiTransactionSignatures multi_transaction_signatures = 4
     */
    multiTransactionSignatures: MultiTransactionSignatures[];
}
/**
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.SignedTopologyTransactions
 */
export interface SignedTopologyTransactions {
    /**
     * serialized signed topology transaction (protobuf bytestring)
     *
     * @generated from protobuf field: repeated bytes signed_transaction = 1
     */
    signedTransaction: Uint8Array[];
}
/**
 * * Accepted topology transaction
 *
 * A member sends topology transactions to the topology transaction broadcast address.
 * The transactions are validated by all members individually against their respective synchronizer store,
 * including the member the submitted the broadcast.
 *
 * @generated from protobuf message com.digitalasset.canton.protocol.v30.TopologyTransactionsBroadcast
 */
export interface TopologyTransactionsBroadcast {
    /**
     * @generated from protobuf field: string synchronizer_id = 1
     */
    synchronizerId: string;
    /**
     * @generated from protobuf field: com.digitalasset.canton.protocol.v30.SignedTopologyTransactions signed_transactions = 2
     */
    signedTransactions?: SignedTopologyTransactions;
}
declare class Enums$Type extends MessageType<Enums> {
    constructor();
    create(value?: PartialMessage<Enums>): Enums;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Enums): Enums;
    internalBinaryWrite(message: Enums, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.Enums
 */
export declare const Enums: Enums$Type;
declare class NamespaceDelegation$Type extends MessageType<NamespaceDelegation> {
    constructor();
    create(value?: PartialMessage<NamespaceDelegation>): NamespaceDelegation;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NamespaceDelegation): NamespaceDelegation;
    internalBinaryWrite(message: NamespaceDelegation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation
 */
export declare const NamespaceDelegation: NamespaceDelegation$Type;
declare class NamespaceDelegation_CanSignAllMappings$Type extends MessageType<NamespaceDelegation_CanSignAllMappings> {
    constructor();
    create(value?: PartialMessage<NamespaceDelegation_CanSignAllMappings>): NamespaceDelegation_CanSignAllMappings;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NamespaceDelegation_CanSignAllMappings): NamespaceDelegation_CanSignAllMappings;
    internalBinaryWrite(message: NamespaceDelegation_CanSignAllMappings, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignAllMappings
 */
export declare const NamespaceDelegation_CanSignAllMappings: NamespaceDelegation_CanSignAllMappings$Type;
declare class NamespaceDelegation_CanSignAllButNamespaceDelegations$Type extends MessageType<NamespaceDelegation_CanSignAllButNamespaceDelegations> {
    constructor();
    create(value?: PartialMessage<NamespaceDelegation_CanSignAllButNamespaceDelegations>): NamespaceDelegation_CanSignAllButNamespaceDelegations;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NamespaceDelegation_CanSignAllButNamespaceDelegations): NamespaceDelegation_CanSignAllButNamespaceDelegations;
    internalBinaryWrite(message: NamespaceDelegation_CanSignAllButNamespaceDelegations, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignAllButNamespaceDelegations
 */
export declare const NamespaceDelegation_CanSignAllButNamespaceDelegations: NamespaceDelegation_CanSignAllButNamespaceDelegations$Type;
declare class NamespaceDelegation_CanSignSpecificMappings$Type extends MessageType<NamespaceDelegation_CanSignSpecificMappings> {
    constructor();
    create(value?: PartialMessage<NamespaceDelegation_CanSignSpecificMappings>): NamespaceDelegation_CanSignSpecificMappings;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NamespaceDelegation_CanSignSpecificMappings): NamespaceDelegation_CanSignSpecificMappings;
    internalBinaryWrite(message: NamespaceDelegation_CanSignSpecificMappings, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.NamespaceDelegation.CanSignSpecificMappings
 */
export declare const NamespaceDelegation_CanSignSpecificMappings: NamespaceDelegation_CanSignSpecificMappings$Type;
declare class DecentralizedNamespaceDefinition$Type extends MessageType<DecentralizedNamespaceDefinition> {
    constructor();
    create(value?: PartialMessage<DecentralizedNamespaceDefinition>): DecentralizedNamespaceDefinition;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DecentralizedNamespaceDefinition): DecentralizedNamespaceDefinition;
    internalBinaryWrite(message: DecentralizedNamespaceDefinition, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.DecentralizedNamespaceDefinition
 */
export declare const DecentralizedNamespaceDefinition: DecentralizedNamespaceDefinition$Type;
declare class OwnerToKeyMapping$Type extends MessageType<OwnerToKeyMapping> {
    constructor();
    create(value?: PartialMessage<OwnerToKeyMapping>): OwnerToKeyMapping;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OwnerToKeyMapping): OwnerToKeyMapping;
    internalBinaryWrite(message: OwnerToKeyMapping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.OwnerToKeyMapping
 */
export declare const OwnerToKeyMapping: OwnerToKeyMapping$Type;
declare class PartyToKeyMapping$Type extends MessageType<PartyToKeyMapping> {
    constructor();
    create(value?: PartialMessage<PartyToKeyMapping>): PartyToKeyMapping;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartyToKeyMapping): PartyToKeyMapping;
    internalBinaryWrite(message: PartyToKeyMapping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.PartyToKeyMapping
 */
export declare const PartyToKeyMapping: PartyToKeyMapping$Type;
declare class SynchronizerTrustCertificate$Type extends MessageType<SynchronizerTrustCertificate> {
    constructor();
    create(value?: PartialMessage<SynchronizerTrustCertificate>): SynchronizerTrustCertificate;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SynchronizerTrustCertificate): SynchronizerTrustCertificate;
    internalBinaryWrite(message: SynchronizerTrustCertificate, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.SynchronizerTrustCertificate
 */
export declare const SynchronizerTrustCertificate: SynchronizerTrustCertificate$Type;
declare class ParticipantSynchronizerPermission$Type extends MessageType<ParticipantSynchronizerPermission> {
    constructor();
    create(value?: PartialMessage<ParticipantSynchronizerPermission>): ParticipantSynchronizerPermission;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParticipantSynchronizerPermission): ParticipantSynchronizerPermission;
    internalBinaryWrite(message: ParticipantSynchronizerPermission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.ParticipantSynchronizerPermission
 */
export declare const ParticipantSynchronizerPermission: ParticipantSynchronizerPermission$Type;
declare class PartyHostingLimits$Type extends MessageType<PartyHostingLimits> {
    constructor();
    create(value?: PartialMessage<PartyHostingLimits>): PartyHostingLimits;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartyHostingLimits): PartyHostingLimits;
    internalBinaryWrite(message: PartyHostingLimits, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.PartyHostingLimits
 */
export declare const PartyHostingLimits: PartyHostingLimits$Type;
declare class VettedPackages$Type extends MessageType<VettedPackages> {
    constructor();
    create(value?: PartialMessage<VettedPackages>): VettedPackages;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VettedPackages): VettedPackages;
    internalBinaryWrite(message: VettedPackages, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.VettedPackages
 */
export declare const VettedPackages: VettedPackages$Type;
declare class VettedPackages_VettedPackage$Type extends MessageType<VettedPackages_VettedPackage> {
    constructor();
    create(value?: PartialMessage<VettedPackages_VettedPackage>): VettedPackages_VettedPackage;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VettedPackages_VettedPackage): VettedPackages_VettedPackage;
    internalBinaryWrite(message: VettedPackages_VettedPackage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.VettedPackages.VettedPackage
 */
export declare const VettedPackages_VettedPackage: VettedPackages_VettedPackage$Type;
declare class PartyToParticipant$Type extends MessageType<PartyToParticipant> {
    constructor();
    create(value?: PartialMessage<PartyToParticipant>): PartyToParticipant;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartyToParticipant): PartyToParticipant;
    internalBinaryWrite(message: PartyToParticipant, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.PartyToParticipant
 */
export declare const PartyToParticipant: PartyToParticipant$Type;
declare class PartyToParticipant_HostingParticipant$Type extends MessageType<PartyToParticipant_HostingParticipant> {
    constructor();
    create(value?: PartialMessage<PartyToParticipant_HostingParticipant>): PartyToParticipant_HostingParticipant;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartyToParticipant_HostingParticipant): PartyToParticipant_HostingParticipant;
    internalBinaryWrite(message: PartyToParticipant_HostingParticipant, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.PartyToParticipant.HostingParticipant
 */
export declare const PartyToParticipant_HostingParticipant: PartyToParticipant_HostingParticipant$Type;
declare class SynchronizerParametersState$Type extends MessageType<SynchronizerParametersState> {
    constructor();
    create(value?: PartialMessage<SynchronizerParametersState>): SynchronizerParametersState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SynchronizerParametersState): SynchronizerParametersState;
    internalBinaryWrite(message: SynchronizerParametersState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.SynchronizerParametersState
 */
export declare const SynchronizerParametersState: SynchronizerParametersState$Type;
declare class DynamicSequencingParametersState$Type extends MessageType<DynamicSequencingParametersState> {
    constructor();
    create(value?: PartialMessage<DynamicSequencingParametersState>): DynamicSequencingParametersState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DynamicSequencingParametersState): DynamicSequencingParametersState;
    internalBinaryWrite(message: DynamicSequencingParametersState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.DynamicSequencingParametersState
 */
export declare const DynamicSequencingParametersState: DynamicSequencingParametersState$Type;
declare class MediatorSynchronizerState$Type extends MessageType<MediatorSynchronizerState> {
    constructor();
    create(value?: PartialMessage<MediatorSynchronizerState>): MediatorSynchronizerState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MediatorSynchronizerState): MediatorSynchronizerState;
    internalBinaryWrite(message: MediatorSynchronizerState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.MediatorSynchronizerState
 */
export declare const MediatorSynchronizerState: MediatorSynchronizerState$Type;
declare class SequencerSynchronizerState$Type extends MessageType<SequencerSynchronizerState> {
    constructor();
    create(value?: PartialMessage<SequencerSynchronizerState>): SequencerSynchronizerState;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SequencerSynchronizerState): SequencerSynchronizerState;
    internalBinaryWrite(message: SequencerSynchronizerState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.SequencerSynchronizerState
 */
export declare const SequencerSynchronizerState: SequencerSynchronizerState$Type;
declare class PurgeTopologyTransaction$Type extends MessageType<PurgeTopologyTransaction> {
    constructor();
    create(value?: PartialMessage<PurgeTopologyTransaction>): PurgeTopologyTransaction;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PurgeTopologyTransaction): PurgeTopologyTransaction;
    internalBinaryWrite(message: PurgeTopologyTransaction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.PurgeTopologyTransaction
 */
export declare const PurgeTopologyTransaction: PurgeTopologyTransaction$Type;
declare class TopologyMapping$Type extends MessageType<TopologyMapping> {
    constructor();
    create(value?: PartialMessage<TopologyMapping>): TopologyMapping;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TopologyMapping): TopologyMapping;
    internalBinaryWrite(message: TopologyMapping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.TopologyMapping
 */
export declare const TopologyMapping: TopologyMapping$Type;
declare class TopologyTransaction$Type extends MessageType<TopologyTransaction> {
    constructor();
    create(value?: PartialMessage<TopologyTransaction>): TopologyTransaction;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TopologyTransaction): TopologyTransaction;
    internalBinaryWrite(message: TopologyTransaction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.TopologyTransaction
 */
export declare const TopologyTransaction: TopologyTransaction$Type;
declare class MultiTransactionSignatures$Type extends MessageType<MultiTransactionSignatures> {
    constructor();
    create(value?: PartialMessage<MultiTransactionSignatures>): MultiTransactionSignatures;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MultiTransactionSignatures): MultiTransactionSignatures;
    internalBinaryWrite(message: MultiTransactionSignatures, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.MultiTransactionSignatures
 */
export declare const MultiTransactionSignatures: MultiTransactionSignatures$Type;
declare class SignedTopologyTransaction$Type extends MessageType<SignedTopologyTransaction> {
    constructor();
    create(value?: PartialMessage<SignedTopologyTransaction>): SignedTopologyTransaction;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SignedTopologyTransaction): SignedTopologyTransaction;
    internalBinaryWrite(message: SignedTopologyTransaction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.SignedTopologyTransaction
 */
export declare const SignedTopologyTransaction: SignedTopologyTransaction$Type;
declare class SignedTopologyTransactions$Type extends MessageType<SignedTopologyTransactions> {
    constructor();
    create(value?: PartialMessage<SignedTopologyTransactions>): SignedTopologyTransactions;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SignedTopologyTransactions): SignedTopologyTransactions;
    internalBinaryWrite(message: SignedTopologyTransactions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.SignedTopologyTransactions
 */
export declare const SignedTopologyTransactions: SignedTopologyTransactions$Type;
declare class TopologyTransactionsBroadcast$Type extends MessageType<TopologyTransactionsBroadcast> {
    constructor();
    create(value?: PartialMessage<TopologyTransactionsBroadcast>): TopologyTransactionsBroadcast;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TopologyTransactionsBroadcast): TopologyTransactionsBroadcast;
    internalBinaryWrite(message: TopologyTransactionsBroadcast, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.digitalasset.canton.protocol.v30.TopologyTransactionsBroadcast
 */
export declare const TopologyTransactionsBroadcast: TopologyTransactionsBroadcast$Type;
export {};
//# sourceMappingURL=topology.d.ts.map