@typemove/aptos 1.6.0-rc.3 → 1.6.1-rc.1

package/dist/cjs/builtin/0x1.d.ts

@@ -36,6 +36,57 @@ export declare namespace bcs {
     namespace entry { }
     namespace view { }
 }
+export declare namespace dkg {
+    interface DKGSessionMetadata {
+        dealer_epoch: bigint;
+        randomness_config: randomness_config.RandomnessConfig;
+        dealer_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
+        target_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
+    }
+    namespace DKGSessionMetadata {
+        const TYPE_QNAME = "0x1::dkg::DKGSessionMetadata";
+        function type(): TypeDescriptor<DKGSessionMetadata>;
+    }
+    interface DKGSessionMetadataInstance extends TypedEventInstance<DKGSessionMetadata> {
+        data_decoded: DKGSessionMetadata;
+        type_arguments: [];
+    }
+    interface DKGSessionState {
+        metadata: dkg.DKGSessionMetadata;
+        start_time_us: bigint;
+        transcript: string;
+    }
+    namespace DKGSessionState {
+        const TYPE_QNAME = "0x1::dkg::DKGSessionState";
+        function type(): TypeDescriptor<DKGSessionState>;
+    }
+    interface DKGSessionStateInstance extends TypedEventInstance<DKGSessionState> {
+        data_decoded: DKGSessionState;
+        type_arguments: [];
+    }
+    interface DKGStartEvent {
+        session_metadata: dkg.DKGSessionMetadata;
+        start_time_us: bigint;
+    }
+    namespace DKGStartEvent {
+        const TYPE_QNAME = "0x1::dkg::DKGStartEvent";
+        function type(): TypeDescriptor<DKGStartEvent>;
+    }
+    interface DKGStartEventInstance extends TypedEventInstance<DKGStartEvent> {
+        data_decoded: DKGStartEvent;
+        type_arguments: [];
+    }
+    interface DKGState {
+        last_completed: option.Option<dkg.DKGSessionState>;
+        in_progress: option.Option<dkg.DKGSessionState>;
+    }
+    namespace DKGState {
+        const TYPE_QNAME = "0x1::dkg::DKGState";
+        function type(): TypeDescriptor<DKGState>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace code {
     interface AllowedDep {
         account: MoveAddressType;
@@ -459,6 +510,10 @@ export declare namespace jwks {
         const TYPE_QNAME = "0x1::jwks::SupportedOIDCProviders";
         function type(): TypeDescriptor<SupportedOIDCProviders>;
     }
+    interface SupportedOIDCProvidersInstance extends TypedEventInstance<SupportedOIDCProviders> {
+        data_decoded: SupportedOIDCProviders;
+        type_arguments: [];
+    }
     interface UnsupportedJWK {
         id: string;
         payload: string;
@@ -489,6 +544,15 @@ export declare namespace block {
         const TYPE_QNAME = "0x1::block::BlockResource";
         function type(): TypeDescriptor<BlockResource>;
     }
+    interface CommitHistory {
+        max_capacity: number;
+        next_idx: number;
+        table: table_with_length.TableWithLength<number, block.NewBlockEvent>;
+    }
+    namespace CommitHistory {
+        const TYPE_QNAME = "0x1::block::CommitHistory";
+        function type(): TypeDescriptor<CommitHistory>;
+    }
     interface NewBlockEvent {
         hash: MoveAddressType;
         epoch: bigint;
@@ -792,6 +856,10 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::ValidatorSet";
         function type(): TypeDescriptor<ValidatorSet>;
     }
+    interface ValidatorSetInstance extends TypedEventInstance<ValidatorSet> {
+        data_decoded: ValidatorSet;
+        type_arguments: [];
+    }
     interface WithdrawStakeEvent {
         pool_address: MoveAddressType;
         amount_withdrawn: bigint;
@@ -1545,7 +1613,15 @@ export declare namespace version {
         const TYPE_QNAME = "0x1::version::Version";
         function type(): TypeDescriptor<Version>;
     }
+    interface VersionInstance extends TypedEventInstance<Version> {
+        data_decoded: Version;
+        type_arguments: [];
+    }
     namespace entry {
+        function setForNextEpoch(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function setVersion(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint];
@@ -1972,6 +2048,13 @@ export declare namespace features {
         const TYPE_QNAME = "0x1::features::Features";
         function type(): TypeDescriptor<Features>;
     }
+    interface PendingFeatures {
+        features: string;
+    }
+    namespace PendingFeatures {
+        const TYPE_QNAME = "0x1::features::PendingFeatures";
+        function type(): TypeDescriptor<PendingFeatures>;
+    }
     namespace entry { }
     namespace view {
         function isEnabled(client: Aptos, request: {
@@ -2194,6 +2277,30 @@ export declare namespace math_fixed {
     namespace entry { }
     namespace view { }
 }
+export declare namespace randomness {
+    interface PerBlockRandomness {
+        epoch: bigint;
+        round: bigint;
+        seed: option.Option<string>;
+    }
+    namespace PerBlockRandomness {
+        const TYPE_QNAME = "0x1::randomness::PerBlockRandomness";
+        function type(): TypeDescriptor<PerBlockRandomness>;
+    }
+    interface RandomnessGeneratedEvent {
+        dummy_field: Boolean;
+    }
+    namespace RandomnessGeneratedEvent {
+        const TYPE_QNAME = "0x1::randomness::RandomnessGeneratedEvent";
+        function type(): TypeDescriptor<RandomnessGeneratedEvent>;
+    }
+    interface RandomnessGeneratedEventInstance extends TypedEventInstance<RandomnessGeneratedEvent> {
+        data_decoded: RandomnessGeneratedEvent;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace simple_map {
     interface Element<T0, T1> {
         key: T0;
@@ -2371,6 +2478,10 @@ export declare namespace gas_schedule {
         const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
         function type(): TypeDescriptor<GasScheduleV2>;
     }
+    interface GasScheduleV2Instance extends TypedEventInstance<GasScheduleV2> {
+        data_decoded: GasScheduleV2;
+        type_arguments: [];
+    }
     namespace entry { }
     namespace view { }
 }
@@ -2701,6 +2812,17 @@ export declare namespace bn254_algebra {
     namespace entry { }
     namespace view { }
 }
+export declare namespace config_buffer {
+    interface PendingConfigs {
+        configs: simple_map.SimpleMap<string, any_.Any>;
+    }
+    namespace PendingConfigs {
+        const TYPE_QNAME = "0x1::config_buffer::PendingConfigs";
+        function type(): TypeDescriptor<PendingConfigs>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace create_signer {
     namespace entry { }
     namespace view { }
@@ -3057,6 +3179,18 @@ export declare namespace delegation_pool {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface AllowlistDelegator {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+    }
+    namespace AllowlistDelegator {
+        const TYPE_QNAME = "0x1::delegation_pool::AllowlistDelegator";
+        function type(): TypeDescriptor<AllowlistDelegator>;
+    }
+    interface AllowlistDelegatorInstance extends TypedEventInstance<AllowlistDelegator> {
+        data_decoded: AllowlistDelegator;
+        type_arguments: [];
+    }
     interface BeneficiaryForOperator {
         beneficiary_for_operator: MoveAddressType;
     }
@@ -3135,6 +3269,13 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::DelegationPool";
         function type(): TypeDescriptor<DelegationPool>;
     }
+    interface DelegationPoolAllowlisting {
+        allowlist: smart_table.SmartTable<MoveAddressType, Boolean>;
+    }
+    namespace DelegationPoolAllowlisting {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolAllowlisting";
+        function type(): TypeDescriptor<DelegationPoolAllowlisting>;
+    }
     interface DelegationPoolOwnership {
         pool_address: MoveAddressType;
     }
@@ -3142,6 +3283,17 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
         function type(): TypeDescriptor<DelegationPoolOwnership>;
     }
+    interface DisableDelegatorsAllowlisting {
+        pool_address: MoveAddressType;
+    }
+    namespace DisableDelegatorsAllowlisting {
+        const TYPE_QNAME = "0x1::delegation_pool::DisableDelegatorsAllowlisting";
+        function type(): TypeDescriptor<DisableDelegatorsAllowlisting>;
+    }
+    interface DisableDelegatorsAllowlistingInstance extends TypedEventInstance<DisableDelegatorsAllowlisting> {
+        data_decoded: DisableDelegatorsAllowlisting;
+        type_arguments: [];
+    }
     interface DistributeCommission {
         pool_address: MoveAddressType;
         operator: MoveAddressType;
@@ -3171,6 +3323,29 @@ export declare namespace delegation_pool {
         data_decoded: DistributeCommissionEvent;
         type_arguments: [];
     }
+    interface EnableDelegatorsAllowlisting {
+        pool_address: MoveAddressType;
+    }
+    namespace EnableDelegatorsAllowlisting {
+        const TYPE_QNAME = "0x1::delegation_pool::EnableDelegatorsAllowlisting";
+        function type(): TypeDescriptor<EnableDelegatorsAllowlisting>;
+    }
+    interface EnableDelegatorsAllowlistingInstance extends TypedEventInstance<EnableDelegatorsAllowlisting> {
+        data_decoded: EnableDelegatorsAllowlisting;
+        type_arguments: [];
+    }
+    interface EvictDelegator {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+    }
+    namespace EvictDelegator {
+        const TYPE_QNAME = "0x1::delegation_pool::EvictDelegator";
+        function type(): TypeDescriptor<EvictDelegator>;
+    }
+    interface EvictDelegatorInstance extends TypedEventInstance<EvictDelegator> {
+        data_decoded: EvictDelegator;
+        type_arguments: [];
+    }
     interface GovernanceRecords {
         votes: smart_table.SmartTable<delegation_pool.VotingRecordKey, bigint>;
         votes_per_proposal: smart_table.SmartTable<bigint, bigint>;
@@ -3216,6 +3391,18 @@ export declare namespace delegation_pool {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
+    interface RemoveDelegatorFromAllowlist {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+    }
+    namespace RemoveDelegatorFromAllowlist {
+        const TYPE_QNAME = "0x1::delegation_pool::RemoveDelegatorFromAllowlist";
+        function type(): TypeDescriptor<RemoveDelegatorFromAllowlist>;
+    }
+    interface RemoveDelegatorFromAllowlistInstance extends TypedEventInstance<RemoveDelegatorFromAllowlist> {
+        data_decoded: RemoveDelegatorFromAllowlist;
+        type_arguments: [];
+    }
     interface SetBeneficiaryForOperator {
         operator: MoveAddressType;
         old_beneficiary: MoveAddressType;
@@ -3300,6 +3487,10 @@ export declare namespace delegation_pool {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function allowlistDelegator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function createProposal(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, string, string, string, Boolean];
@@ -3308,10 +3499,22 @@ export declare namespace delegation_pool {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function disableDelegatorsAllowlisting(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function enableDelegatorsAllowlisting(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function enablePartialGovernanceVoting(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function evictDelegator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function initializeDelegationPool(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint, string];
@@ -3320,6 +3523,10 @@ export declare namespace delegation_pool {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeDelegatorFromAllowlist(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
@@ -3354,6 +3561,9 @@ export declare namespace delegation_pool {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
+        function allowlistingEnabled(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[Boolean]>;
         function beneficiaryForOperator(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
@@ -3372,12 +3582,18 @@ export declare namespace delegation_pool {
         function delegationPoolExists(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
+        function delegatorAllowlisted(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[Boolean]>;
         function getAddStakeFee(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[bigint]>;
         function getDelegationPoolStake(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getDelegatorsAllowlist(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
         function getExpectedStakePoolAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType, string];
         }, version?: bigint): Promise<[MoveAddressType]>;
@@ -3638,10 +3854,22 @@ export declare namespace aptos_governance {
             typeArguments: [];
             functionArguments: [MoveAddressType, string, string, string, Boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function forceEndEpoch(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function forceEndEpochTestOnly(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function partialVote(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint, bigint, Boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reconfigure(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function vote(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint, Boolean];
@@ -3779,6 +4007,10 @@ export declare namespace consensus_config {
         const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
         function type(): TypeDescriptor<ConsensusConfig>;
     }
+    interface ConsensusConfigInstance extends TypedEventInstance<ConsensusConfig> {
+        data_decoded: ConsensusConfig;
+        type_arguments: [];
+    }
     namespace entry { }
     namespace view { }
 }
@@ -3790,6 +4022,10 @@ export declare namespace execution_config {
         const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
         function type(): TypeDescriptor<ExecutionConfig>;
     }
+    interface ExecutionConfigInstance extends TypedEventInstance<ExecutionConfig> {
+        data_decoded: ExecutionConfig;
+        type_arguments: [];
+    }
     namespace entry { }
     namespace view { }
 }
@@ -4047,6 +4283,10 @@ export declare namespace multisig_account {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function executeRejectedTransactions(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function rejectTransaction(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
@@ -4079,18 +4319,35 @@ export declare namespace multisig_account {
             typeArguments: [];
             functionArguments: [bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function voteTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function voteTransactions(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, Boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function voteTransanction(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint, Boolean];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
+        function availableTransactionQueueCapacity(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function canBeExecuted(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
         function canBeRejected(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[Boolean]>;
+        function canExecute(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function canReject(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
         function getNextMultisigAccountAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
@@ -4103,6 +4360,9 @@ export declare namespace multisig_account {
         function getTransaction(client: Aptos, request: {
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
+        function isOwner(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[Boolean]>;
         function lastResolvedSequenceNumber(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
@@ -4447,6 +4707,57 @@ export declare namespace system_addresses {
     namespace entry { }
     namespace view { }
 }
+export declare namespace randomness_config {
+    interface ConfigOff {
+        dummy_field: Boolean;
+    }
+    namespace ConfigOff {
+        const TYPE_QNAME = "0x1::randomness_config::ConfigOff";
+        function type(): TypeDescriptor<ConfigOff>;
+    }
+    interface ConfigOffInstance extends TypedEventInstance<ConfigOff> {
+        data_decoded: ConfigOff;
+        type_arguments: [];
+    }
+    interface ConfigV1 {
+        secrecy_threshold: fixed_point64.FixedPoint64;
+        reconstruction_threshold: fixed_point64.FixedPoint64;
+    }
+    namespace ConfigV1 {
+        const TYPE_QNAME = "0x1::randomness_config::ConfigV1";
+        function type(): TypeDescriptor<ConfigV1>;
+    }
+    interface ConfigV1Instance extends TypedEventInstance<ConfigV1> {
+        data_decoded: ConfigV1;
+        type_arguments: [];
+    }
+    interface ConfigV2 {
+        secrecy_threshold: fixed_point64.FixedPoint64;
+        reconstruction_threshold: fixed_point64.FixedPoint64;
+        fast_path_secrecy_threshold: fixed_point64.FixedPoint64;
+    }
+    namespace ConfigV2 {
+        const TYPE_QNAME = "0x1::randomness_config::ConfigV2";
+        function type(): TypeDescriptor<ConfigV2>;
+    }
+    interface ConfigV2Instance extends TypedEventInstance<ConfigV2> {
+        data_decoded: ConfigV2;
+        type_arguments: [];
+    }
+    interface RandomnessConfig {
+        variant: copyable_any.Any;
+    }
+    namespace RandomnessConfig {
+        const TYPE_QNAME = "0x1::randomness_config::RandomnessConfig";
+        function type(): TypeDescriptor<RandomnessConfig>;
+    }
+    interface RandomnessConfigInstance extends TypedEventInstance<RandomnessConfig> {
+        data_decoded: RandomnessConfig;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace table_with_length {
     interface TableWithLength<T0, T1> {
         inner: table.Table<T0, T1>;
@@ -4520,6 +4831,55 @@ export declare namespace transaction_context {
     namespace entry { }
     namespace view { }
 }
+export declare namespace jwk_consensus_config {
+    interface ConfigOff {
+        dummy_field: Boolean;
+    }
+    namespace ConfigOff {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigOff";
+        function type(): TypeDescriptor<ConfigOff>;
+    }
+    interface ConfigOffInstance extends TypedEventInstance<ConfigOff> {
+        data_decoded: ConfigOff;
+        type_arguments: [];
+    }
+    interface ConfigV1 {
+        oidc_providers: jwk_consensus_config.OIDCProvider[];
+    }
+    namespace ConfigV1 {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigV1";
+        function type(): TypeDescriptor<ConfigV1>;
+    }
+    interface ConfigV1Instance extends TypedEventInstance<ConfigV1> {
+        data_decoded: ConfigV1;
+        type_arguments: [];
+    }
+    interface JWKConsensusConfig {
+        variant: copyable_any.Any;
+    }
+    namespace JWKConsensusConfig {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";
+        function type(): TypeDescriptor<JWKConsensusConfig>;
+    }
+    interface JWKConsensusConfigInstance extends TypedEventInstance<JWKConsensusConfig> {
+        data_decoded: JWKConsensusConfig;
+        type_arguments: [];
+    }
+    interface OIDCProvider {
+        name: string;
+        config_url: string;
+    }
+    namespace OIDCProvider {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::OIDCProvider";
+        function type(): TypeDescriptor<OIDCProvider>;
+    }
+    interface OIDCProviderInstance extends TypedEventInstance<OIDCProvider> {
+        data_decoded: OIDCProvider;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace ristretto255_elgamal {
     interface Ciphertext {
         left: ristretto255.RistrettoPoint;
@@ -4555,6 +4915,39 @@ export declare namespace ristretto255_elgamal {
     namespace entry { }
     namespace view { }
 }
+export declare namespace reconfiguration_state {
+    interface State {
+        variant: copyable_any.Any;
+    }
+    namespace State {
+        const TYPE_QNAME = "0x1::reconfiguration_state::State";
+        function type(): TypeDescriptor<State>;
+    }
+    interface StateActive {
+        start_time_secs: bigint;
+    }
+    namespace StateActive {
+        const TYPE_QNAME = "0x1::reconfiguration_state::StateActive";
+        function type(): TypeDescriptor<StateActive>;
+    }
+    interface StateActiveInstance extends TypedEventInstance<StateActive> {
+        data_decoded: StateActive;
+        type_arguments: [];
+    }
+    interface StateInactive {
+        dummy_field: Boolean;
+    }
+    namespace StateInactive {
+        const TYPE_QNAME = "0x1::reconfiguration_state::StateInactive";
+        function type(): TypeDescriptor<StateInactive>;
+    }
+    interface StateInactiveInstance extends TypedEventInstance<StateInactive> {
+        data_decoded: StateInactive;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace ristretto255_pedersen {
     interface Commitment {
         point: ristretto255.RistrettoPoint;
@@ -4680,6 +5073,27 @@ export declare namespace transaction_validation {
     namespace entry { }
     namespace view { }
 }
+export declare namespace reconfiguration_with_dkg {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace validator_consensus_info {
+    interface ValidatorConsensusInfo {
+        addr: MoveAddressType;
+        pk_bytes: string;
+        voting_power: bigint;
+    }
+    namespace ValidatorConsensusInfo {
+        const TYPE_QNAME = "0x1::validator_consensus_info::ValidatorConsensusInfo";
+        function type(): TypeDescriptor<ValidatorConsensusInfo>;
+    }
+    interface ValidatorConsensusInfoInstance extends TypedEventInstance<ValidatorConsensusInfo> {
+        data_decoded: ValidatorConsensusInfo;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace ristretto255_bulletproofs {
     interface RangeProof {
         bytes: string;