@sentio/sdk 2.59.0-rc.1 → 2.59.0-rc.10

package/lib/aptos/builtin/0x1.d.ts

@@ -30,6 +30,16 @@ export declare namespace bcs {
     namespace entry { }
     namespace view { }
 }
+export declare namespace cmp {
+    interface Ordering {
+    }
+    namespace Ordering {
+        const TYPE_QNAME = "0x1::cmp::Ordering";
+        function type(): TypeDescriptor<Ordering>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare class dkg extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -99,6 +109,13 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::AllowedDep";
         function type(): TypeDescriptor<AllowedDep>;
     }
+    interface CodePublishingPermission {
+        dummy_field: boolean;
+    }
+    namespace CodePublishingPermission {
+        const TYPE_QNAME = "0x1::code::CodePublishingPermission";
+        function type(): TypeDescriptor<CodePublishingPermission>;
+    }
     interface ModuleMetadata {
         name: string;
         source: string;
@@ -185,6 +202,7 @@ export declare class coin extends AptosBaseProcessor {
     onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): coin;
     onEventCoinDeposit(func: (event: coin.CoinDepositInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): coin;
     onEventCoinEventHandleDeletion(func: (event: coin.CoinEventHandleDeletionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): coin;
+    onEventCoinStoreDeletion(func: (event: coin.CoinStoreDeletionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): coin;
     onEventCoinWithdraw(func: (event: coin.CoinWithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): coin;
     onEventPairCreation(func: (event: coin.PairCreationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): coin;
 }
@@ -308,6 +326,20 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::CoinStore";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinStore<T0>>;
     }
+    interface CoinStoreDeletion {
+        coin_type: string;
+        event_handle_creation_address: MoveAddressType;
+        deleted_deposit_event_handle_creation_number: bigint;
+        deleted_withdraw_event_handle_creation_number: bigint;
+    }
+    namespace CoinStoreDeletion {
+        const TYPE_QNAME = "0x1::coin::CoinStoreDeletion";
+        function type(): TypeDescriptor<CoinStoreDeletion>;
+    }
+    type CoinStoreDeletionInstance = TypedEventInstance<CoinStoreDeletion> & {
+        data_decoded: CoinStoreDeletion;
+        type_arguments: [];
+    };
     interface CoinWithdraw {
         coin_type: string;
         account: MoveAddressType;
@@ -1099,6 +1131,13 @@ export declare namespace stake {
         data_decoded: SetOperatorEvent;
         type_arguments: [];
     };
+    interface StakeManagementPermission {
+        dummy_field: boolean;
+    }
+    namespace StakeManagementPermission {
+        const TYPE_QNAME = "0x1::stake::StakeManagementPermission";
+        function type(): TypeDescriptor<StakeManagementPermission>;
+    }
     interface StakePool {
         active: coin.Coin<aptos_coin.AptosCoin>;
         inactive: coin.Coin<aptos_coin.AptosCoin>;
@@ -1516,6 +1555,13 @@ export declare namespace object$ {
         data_decoded: TransferEvent;
         type_arguments: [];
     };
+    interface TransferPermission {
+        object: MoveAddressType;
+    }
+    namespace TransferPermission {
+        const TYPE_QNAME = "0x1::object::TransferPermission";
+        function type(): TypeDescriptor<TransferPermission>;
+    }
     interface TransferRef {
         self: MoveAddressType;
     }
@@ -1738,6 +1784,13 @@ export declare namespace voting {
         data_decoded: VoteEvent;
         type_arguments: [];
     };
+    interface VotePermission {
+        dummy_field: boolean;
+    }
+    namespace VotePermission {
+        const TYPE_QNAME = "0x1::voting::VotePermission";
+        function type(): TypeDescriptor<VotePermission>;
+    }
     interface VotingEvents {
         create_proposal_events: event.EventHandle<voting.CreateProposalEvent>;
         register_forum_events: event.EventHandle<voting.RegisterForumEvent>;
@@ -1854,6 +1907,12 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::Account";
         function type(): TypeDescriptor<Account>;
     }
+    interface AccountPermission {
+    }
+    namespace AccountPermission {
+        const TYPE_QNAME = "0x1::account::AccountPermission";
+        function type(): TypeDescriptor<AccountPermission>;
+    }
     interface CapabilityOffer<T0> {
         for: option.Option<MoveAddressType>;
     }
@@ -2570,6 +2629,13 @@ export declare namespace vesting {
         data_decoded: VestEvent;
         type_arguments: [];
     };
+    interface VestPermission {
+        dummy_field: boolean;
+    }
+    namespace VestPermission {
+        const TYPE_QNAME = "0x1::vesting::VestPermission";
+        function type(): TypeDescriptor<VestPermission>;
+    }
     interface VestingAccountManagement {
         roles: simple_map.SimpleMap<string, MoveAddressType>;
     }
@@ -2907,6 +2973,16 @@ export declare namespace pool_u64 {
     namespace entry { }
     namespace view { }
 }
+export declare namespace auth_data {
+    interface AbstractionAuthData {
+    }
+    namespace AbstractionAuthData {
+        const TYPE_QNAME = "0x1::auth_data::AbstractionAuthData";
+        function type(): TypeDescriptor<AbstractionAuthData>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace secp256k1 {
     interface ECDSARawPublicKey {
         bytes: string;
@@ -3034,6 +3110,33 @@ export declare namespace aptos_hash {
     namespace entry { }
     namespace view { }
 }
+export declare class bcs_stream extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): bcs_stream;
+    onEntryDeserializeU256Entry(func: (call: bcs_stream.DeserializeU256EntryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): bcs_stream;
+}
+export declare namespace bcs_stream {
+    interface BCSStream {
+        data: string;
+        cur: bigint;
+    }
+    namespace BCSStream {
+        const TYPE_QNAME = "0x1::bcs_stream::BCSStream";
+        function type(): TypeDescriptor<BCSStream>;
+    }
+    namespace entry {
+        function deserializeU256Entry(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
+    interface DeserializeU256EntryPayload extends TypedFunctionPayload<[string, bigint]> {
+        arguments_decoded: [string, bigint];
+        type_arguments: [];
+    }
+}
 export declare namespace big_vector {
     interface BigVector<T0> {
         buckets: table_with_length.TableWithLength<bigint, T0[]>;
@@ -3155,6 +3258,30 @@ export declare namespace simple_map {
     namespace entry { }
     namespace view { }
 }
+export declare namespace ordered_map {
+    interface Entry<T0, T1> {
+        key: T0;
+        value: T1;
+    }
+    namespace Entry {
+        const TYPE_QNAME = "0x1::ordered_map::Entry";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Entry<T0, T1>>;
+    }
+    interface IteratorPtr {
+    }
+    namespace IteratorPtr {
+        const TYPE_QNAME = "0x1::ordered_map::IteratorPtr";
+        function type(): TypeDescriptor<IteratorPtr>;
+    }
+    interface OrderedMap<T0, T1> {
+    }
+    namespace OrderedMap {
+        const TYPE_QNAME = "0x1::ordered_map::OrderedMap";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<OrderedMap<T0, T1>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace smart_table {
     interface Entry<T0, T1> {
         hash: bigint;
@@ -3352,6 +3479,16 @@ export declare namespace math_fixed64 {
     namespace entry { }
     namespace view { }
 }
+export declare namespace rate_limiter {
+    interface RateLimiter {
+    }
+    namespace RateLimiter {
+        const TYPE_QNAME = "0x1::rate_limiter::RateLimiter";
+        function type(): TypeDescriptor<RateLimiter>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace ristretto255 {
     interface CompressedRistretto {
         data: string;
@@ -3802,6 +3939,13 @@ export declare class staking_proxy extends AptosBaseProcessor {
     onEntrySetVoter(func: (call: staking_proxy.SetVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_proxy;
 }
 export declare namespace staking_proxy {
+    interface StakeProxyPermission {
+        dummy_field: boolean;
+    }
+    namespace StakeProxyPermission {
+        const TYPE_QNAME = "0x1::staking_proxy::StakeProxyPermission";
+        function type(): TypeDescriptor<StakeProxyPermission>;
+    }
     namespace entry {
         function setOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
@@ -3918,6 +4062,7 @@ export declare class fungible_asset extends AptosBaseProcessor {
     onEventDepositEvent(func: (event: fungible_asset.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): fungible_asset;
     onEventFrozen(func: (event: fungible_asset.FrozenInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): fungible_asset;
     onEventFrozenEvent(func: (event: fungible_asset.FrozenEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): fungible_asset;
+    onEventFungibleStoreDeletion(func: (event: fungible_asset.FungibleStoreDeletionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): fungible_asset;
     onEventWithdraw(func: (event: fungible_asset.WithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): fungible_asset;
     onEventWithdrawEvent(func: (event: fungible_asset.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): fungible_asset;
 }
@@ -4045,6 +4190,19 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::FungibleStore";
         function type(): TypeDescriptor<FungibleStore>;
     }
+    interface FungibleStoreDeletion {
+        store: MoveAddressType;
+        owner: MoveAddressType;
+        metadata: MoveAddressType;
+    }
+    namespace FungibleStoreDeletion {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleStoreDeletion";
+        function type(): TypeDescriptor<FungibleStoreDeletion>;
+    }
+    type FungibleStoreDeletionInstance = TypedEventInstance<FungibleStoreDeletion> & {
+        data_decoded: FungibleStoreDeletion;
+        type_arguments: [];
+    };
     interface Metadata {
         name: string;
         symbol: string;
@@ -4070,6 +4228,20 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::MutateMetadataRef";
         function type(): TypeDescriptor<MutateMetadataRef>;
     }
+    interface RawBalanceRef {
+        metadata: object$.Object<fungible_asset.Metadata>;
+    }
+    namespace RawBalanceRef {
+        const TYPE_QNAME = "0x1::fungible_asset::RawBalanceRef";
+        function type(): TypeDescriptor<RawBalanceRef>;
+    }
+    interface RawSupplyRef {
+        metadata: object$.Object<fungible_asset.Metadata>;
+    }
+    namespace RawSupplyRef {
+        const TYPE_QNAME = "0x1::fungible_asset::RawSupplyRef";
+        function type(): TypeDescriptor<RawSupplyRef>;
+    }
     interface Supply {
         current: bigint;
         maximum: option.Option<bigint>;
@@ -4101,6 +4273,12 @@ export declare namespace fungible_asset {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     };
+    interface WithdrawPermission {
+    }
+    namespace WithdrawPermission {
+        const TYPE_QNAME = "0x1::fungible_asset::WithdrawPermission";
+        function type(): TypeDescriptor<WithdrawPermission>;
+    }
     namespace entry {
         function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
@@ -4215,6 +4393,34 @@ export declare namespace staking_config {
         function rewardRate(client: Aptos, version?: bigint): Promise<[bigint, bigint]>;
     }
 }
+export declare namespace big_ordered_map {
+    interface IteratorPtr<T0> {
+    }
+    namespace IteratorPtr {
+        const TYPE_QNAME = "0x1::big_ordered_map::IteratorPtr";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<IteratorPtr<T0>>;
+    }
+    interface BigOrderedMap<T0, T1> {
+    }
+    namespace BigOrderedMap {
+        const TYPE_QNAME = "0x1::big_ordered_map::BigOrderedMap";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<BigOrderedMap<T0, T1>>;
+    }
+    interface Child<T0> {
+    }
+    namespace Child {
+        const TYPE_QNAME = "0x1::big_ordered_map::Child";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Child<T0>>;
+    }
+    interface Node<T0, T1> {
+    }
+    namespace Node {
+        const TYPE_QNAME = "0x1::big_ordered_map::Node";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Node<T0, T1>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare class delegation_pool extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -4493,6 +4699,12 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::DelegatedVotes";
         function type(): TypeDescriptor<DelegatedVotes>;
     }
+    interface DelegationPermission {
+    }
+    namespace DelegationPermission {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPermission";
+        function type(): TypeDescriptor<DelegationPermission>;
+    }
     interface DelegationPool {
         active_shares: pool_u64_unbound.Pool;
         observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
@@ -5148,6 +5360,13 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::GovernanceEvents";
         function type(): TypeDescriptor<GovernanceEvents>;
     }
+    interface GovernancePermission {
+        dummy_field: boolean;
+    }
+    namespace GovernancePermission {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernancePermission";
+        function type(): TypeDescriptor<GovernancePermission>;
+    }
     interface GovernanceResponsbility {
         signer_caps: simple_map.SimpleMap<MoveAddressType, account.SignerCapability>;
     }
@@ -6768,6 +6987,142 @@ export declare namespace aggregator_factory {
     namespace entry { }
     namespace view { }
 }
+export declare class account_abstraction extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): account_abstraction;
+    onEntryInitialize(func: (call: account_abstraction.InitializePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryAddAuthenticationFunction(func: (call: account_abstraction.AddAuthenticationFunctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryAddDispatchableAuthenticationFunction(func: (call: account_abstraction.AddDispatchableAuthenticationFunctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryRegisterDerivableAuthenticationFunction(func: (call: account_abstraction.RegisterDerivableAuthenticationFunctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryRemoveAuthenticationFunction(func: (call: account_abstraction.RemoveAuthenticationFunctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryRemoveAuthenticator(func: (call: account_abstraction.RemoveAuthenticatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryRemoveDispatchableAuthenticationFunction(func: (call: account_abstraction.RemoveDispatchableAuthenticationFunctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEntryRemoveDispatchableAuthenticator(func: (call: account_abstraction.RemoveDispatchableAuthenticatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account_abstraction;
+    onEventRemoveDispatchableAuthenticator(func: (event: account_abstraction.RemoveDispatchableAuthenticatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): account_abstraction;
+    onEventUpdateDispatchableAuthenticator(func: (event: account_abstraction.UpdateDispatchableAuthenticatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type" | "account">): account_abstraction;
+}
+export declare namespace account_abstraction {
+    interface DerivableDispatchableAuthenticator {
+    }
+    namespace DerivableDispatchableAuthenticator {
+        const TYPE_QNAME = "0x1::account_abstraction::DerivableDispatchableAuthenticator";
+        function type(): TypeDescriptor<DerivableDispatchableAuthenticator>;
+    }
+    interface DerivableRegisterValue {
+    }
+    namespace DerivableRegisterValue {
+        const TYPE_QNAME = "0x1::account_abstraction::DerivableRegisterValue";
+        function type(): TypeDescriptor<DerivableRegisterValue>;
+    }
+    interface DispatchableAuthenticator {
+    }
+    namespace DispatchableAuthenticator {
+        const TYPE_QNAME = "0x1::account_abstraction::DispatchableAuthenticator";
+        function type(): TypeDescriptor<DispatchableAuthenticator>;
+    }
+    interface RemoveDispatchableAuthenticator {
+        account: MoveAddressType;
+    }
+    namespace RemoveDispatchableAuthenticator {
+        const TYPE_QNAME = "0x1::account_abstraction::RemoveDispatchableAuthenticator";
+        function type(): TypeDescriptor<RemoveDispatchableAuthenticator>;
+    }
+    type RemoveDispatchableAuthenticatorInstance = TypedEventInstance<RemoveDispatchableAuthenticator> & {
+        data_decoded: RemoveDispatchableAuthenticator;
+        type_arguments: [];
+    };
+    interface UpdateDispatchableAuthenticator {
+        account: MoveAddressType;
+        update: string;
+        auth_function: function_info.FunctionInfo;
+    }
+    namespace UpdateDispatchableAuthenticator {
+        const TYPE_QNAME = "0x1::account_abstraction::UpdateDispatchableAuthenticator";
+        function type(): TypeDescriptor<UpdateDispatchableAuthenticator>;
+    }
+    type UpdateDispatchableAuthenticatorInstance = TypedEventInstance<UpdateDispatchableAuthenticator> & {
+        data_decoded: UpdateDispatchableAuthenticator;
+        type_arguments: [];
+    };
+    namespace entry {
+        function initialize(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function addAuthenticationFunction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function addDispatchableAuthenticationFunction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function registerDerivableAuthenticationFunction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeAuthenticationFunction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeAuthenticator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeDispatchableAuthenticationFunction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeDispatchableAuthenticator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function deriveAccountAddressView(client: Aptos, request: {
+            functionArguments: [MoveAddressType, string, string, string];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function dispatchableAuthenticator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[option.Option<function_info.FunctionInfo[]>]>;
+        function usingDispatchableAuthenticator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+    }
+    interface InitializePayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface AddAuthenticationFunctionPayload extends TypedFunctionPayload<[MoveAddressType, string, string]> {
+        arguments_decoded: [MoveAddressType, string, string];
+        type_arguments: [];
+    }
+    interface AddDispatchableAuthenticationFunctionPayload extends TypedFunctionPayload<[MoveAddressType, string, string]> {
+        arguments_decoded: [MoveAddressType, string, string];
+        type_arguments: [];
+    }
+    interface RegisterDerivableAuthenticationFunctionPayload extends TypedFunctionPayload<[MoveAddressType, string, string]> {
+        arguments_decoded: [MoveAddressType, string, string];
+        type_arguments: [];
+    }
+    interface RemoveAuthenticationFunctionPayload extends TypedFunctionPayload<[MoveAddressType, string, string]> {
+        arguments_decoded: [MoveAddressType, string, string];
+        type_arguments: [];
+    }
+    interface RemoveAuthenticatorPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface RemoveDispatchableAuthenticationFunctionPayload extends TypedFunctionPayload<[MoveAddressType, string, string]> {
+        arguments_decoded: [MoveAddressType, string, string];
+        type_arguments: [];
+    }
+    interface RemoveDispatchableAuthenticatorPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+}
 export declare namespace governance_proposal {
     interface GovernanceProposal {
         dummy_field: boolean;
@@ -6799,6 +7154,72 @@ export declare namespace optional_aggregator {
     namespace entry { }
     namespace view { }
 }
+export declare class permissioned_signer extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): permissioned_signer;
+    onEntryRevokeAllHandles(func: (call: permissioned_signer.RevokeAllHandlesPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): permissioned_signer;
+    onEntryRevokePermissionStorageAddress(func: (call: permissioned_signer.RevokePermissionStorageAddressPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): permissioned_signer;
+}
+export declare namespace permissioned_signer {
+    interface GrantedPermissionHandles {
+        active_handles: MoveAddressType[];
+    }
+    namespace GrantedPermissionHandles {
+        const TYPE_QNAME = "0x1::permissioned_signer::GrantedPermissionHandles";
+        function type(): TypeDescriptor<GrantedPermissionHandles>;
+    }
+    interface PermissionStorage {
+    }
+    namespace PermissionStorage {
+        const TYPE_QNAME = "0x1::permissioned_signer::PermissionStorage";
+        function type(): TypeDescriptor<PermissionStorage>;
+    }
+    interface PermissionedHandle {
+    }
+    namespace PermissionedHandle {
+        const TYPE_QNAME = "0x1::permissioned_signer::PermissionedHandle";
+        function type(): TypeDescriptor<PermissionedHandle>;
+    }
+    interface RevokePermissionHandlePermission {
+        dummy_field: boolean;
+    }
+    namespace RevokePermissionHandlePermission {
+        const TYPE_QNAME = "0x1::permissioned_signer::RevokePermissionHandlePermission";
+        function type(): TypeDescriptor<RevokePermissionHandlePermission>;
+    }
+    interface StorablePermissionedHandle {
+    }
+    namespace StorablePermissionedHandle {
+        const TYPE_QNAME = "0x1::permissioned_signer::StorablePermissionedHandle";
+        function type(): TypeDescriptor<StorablePermissionedHandle>;
+    }
+    interface StoredPermission {
+    }
+    namespace StoredPermission {
+        const TYPE_QNAME = "0x1::permissioned_signer::StoredPermission";
+        function type(): TypeDescriptor<StoredPermission>;
+    }
+    namespace entry {
+        function revokeAllHandles(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokePermissionStorageAddress(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
+    interface RevokeAllHandlesPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface RevokePermissionStorageAddressPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
+}
 export declare namespace transaction_context {
     interface AUID {
         unique_address: MoveAddressType;
@@ -7088,6 +7509,13 @@ export declare namespace primary_fungible_store {
     }
 }
 export declare namespace transaction_validation {
+    interface GasPermission {
+        dummy_field: boolean;
+    }
+    namespace GasPermission {
+        const TYPE_QNAME = "0x1::transaction_validation::GasPermission";
+        function type(): TypeDescriptor<GasPermission>;
+    }
     interface TransactionValidation {
         module_addr: MoveAddressType;
         module_name: string;
@@ -7103,6 +7531,59 @@ export declare namespace transaction_validation {
     namespace entry { }
     namespace view { }
 }
+export declare namespace permissioned_delegation {
+    interface AccountDelegation {
+    }
+    namespace AccountDelegation {
+        const TYPE_QNAME = "0x1::permissioned_delegation::AccountDelegation";
+        function type(): TypeDescriptor<AccountDelegation>;
+    }
+    interface DelegationKey {
+    }
+    namespace DelegationKey {
+        const TYPE_QNAME = "0x1::permissioned_delegation::DelegationKey";
+        function type(): TypeDescriptor<DelegationKey>;
+    }
+    interface RegisteredDelegations {
+        delegations: big_ordered_map.BigOrderedMap<permissioned_delegation.DelegationKey, permissioned_delegation.AccountDelegation>;
+    }
+    namespace RegisteredDelegations {
+        const TYPE_QNAME = "0x1::permissioned_delegation::RegisteredDelegations";
+        function type(): TypeDescriptor<RegisteredDelegations>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace storage_slots_allocator {
+    interface Link<T0> {
+    }
+    namespace Link {
+        const TYPE_QNAME = "0x1::storage_slots_allocator::Link";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Link<T0>>;
+    }
+    interface ReservedSlot {
+        slot_index: bigint;
+    }
+    namespace ReservedSlot {
+        const TYPE_QNAME = "0x1::storage_slots_allocator::ReservedSlot";
+        function type(): TypeDescriptor<ReservedSlot>;
+    }
+    interface StorageSlotsAllocator<T0> {
+    }
+    namespace StorageSlotsAllocator {
+        const TYPE_QNAME = "0x1::storage_slots_allocator::StorageSlotsAllocator";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<StorageSlotsAllocator<T0>>;
+    }
+    interface StoredSlot {
+        slot_index: bigint;
+    }
+    namespace StoredSlot {
+        const TYPE_QNAME = "0x1::storage_slots_allocator::StoredSlot";
+        function type(): TypeDescriptor<StoredSlot>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace randomness_api_v0_config {
     interface AllowCustomMaxGasFlag {
         value: boolean;
@@ -7199,6 +7680,10 @@ export declare namespace dispatchable_fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function isDerivedBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>, bigint];
+        }, version?: bigint): Promise<[boolean]>;
     }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
         object$.Object<T0>,