@typemove/aptos 1.0.0-rc.13 → 1.0.0-rc.15

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

@@ -1,6 +1,7 @@
 import { TypeDescriptor } from "@typemove/move";
 import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
 import { Address } from "@typemove/aptos";
+import { AptosClient } from "aptos";
 export declare namespace acl {
     interface ACL {
         list: Address[];
@@ -9,6 +10,7 @@ export declare namespace acl {
         const TYPE_QNAME = "0x1::acl::ACL";
         function type(): TypeDescriptor<ACL>;
     }
+    namespace view { }
 }
 export declare namespace any_ {
     interface Any {
@@ -19,8 +21,11 @@ export declare namespace any_ {
         const TYPE_QNAME = "0x1::any::Any";
         function type(): TypeDescriptor<Any>;
     }
+    namespace view { }
+}
+export declare namespace bcs {
+    namespace view { }
 }
-export declare namespace bcs { }
 export declare namespace code {
     interface AllowedDep {
         account: Address;
@@ -76,6 +81,7 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::UpgradePolicy";
         function type(): TypeDescriptor<UpgradePolicy>;
     }
+    namespace view { }
 }
 export declare namespace coin {
     interface AggregatableCoin<T0> {
@@ -162,6 +168,36 @@ export declare namespace coin {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     }
+    namespace view {
+        function balance<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function decimals<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, version?: bigint): Promise<[number]>;
+        function isAccountRegistered<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isCoinInitialized<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, version?: bigint): Promise<[Boolean]>;
+        function name<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, version?: bigint): Promise<[string]>;
+        function supply<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function symbol<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, version?: bigint): Promise<[string]>;
+    }
 }
 export declare namespace guid {
     interface GUID {
@@ -179,9 +215,14 @@ export declare namespace guid {
         const TYPE_QNAME = "0x1::guid::ID";
         function type(): TypeDescriptor<ID>;
     }
+    namespace view { }
+}
+export declare namespace hash {
+    namespace view { }
+}
+export declare namespace util {
+    namespace view { }
 }
-export declare namespace hash { }
-export declare namespace util { }
 export declare namespace block {
     interface BlockResource {
         height: bigint;
@@ -223,9 +264,23 @@ export declare namespace block {
         data_decoded: UpdateEpochIntervalEvent;
         type_arguments: [];
     }
+    namespace view {
+        function getCurrentBlockHeight(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+        function getEpochIntervalSecs(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace debug {
+    namespace view { }
+}
+export declare namespace error {
+    namespace view { }
 }
-export declare namespace debug { }
-export declare namespace error { }
 export declare namespace event {
     interface EventHandle<T0> {
         counter: bigint;
@@ -235,6 +290,7 @@ export declare namespace event {
         const TYPE_QNAME = "0x1::event::EventHandle";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<EventHandle<T0>>;
     }
+    namespace view { }
 }
 export declare namespace stake {
     interface AddStakeEvent {
@@ -483,6 +539,52 @@ export declare namespace stake {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
     }
+    namespace view {
+        function getCurrentEpochProposalCounts(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, version?: bigint): Promise<[bigint, bigint]>;
+        function getCurrentEpochVotingPower(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getDelegatedVoter(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getLockupSecs(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getOperator(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getRemainingLockupSecs(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getStake(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getValidatorConfig(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[string, string, string]>;
+        function getValidatorIndex(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getValidatorState(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function stakePoolExists(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
 }
 export declare namespace table {
     interface Box<T0> {
@@ -499,8 +601,11 @@ export declare namespace table {
         const TYPE_QNAME = "0x1::table::Table";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Table<T0, T1>>;
     }
+    namespace view { }
+}
+export declare namespace math64 {
+    namespace view { }
 }
-export declare namespace math64 { }
 export declare namespace object_ {
     interface ConstructorRef {
         self: Address;
@@ -517,6 +622,13 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::DeleteRef";
         function type(): TypeDescriptor<DeleteRef>;
     }
+    interface DeriveRef {
+        self: Address;
+    }
+    namespace DeriveRef {
+        const TYPE_QNAME = "0x1::object::DeriveRef";
+        function type(): TypeDescriptor<DeriveRef>;
+    }
     interface ExtendRef {
         self: Address;
     }
@@ -576,6 +688,7 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::TransferRef";
         function type(): TypeDescriptor<TransferRef>;
     }
+    namespace view { }
 }
 export declare namespace option {
     interface Option<T0> {
@@ -585,8 +698,11 @@ export declare namespace option {
         const TYPE_QNAME = "0x1::option::Option";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Option<T0>>;
     }
+    namespace view { }
+}
+export declare namespace signer {
+    namespace view { }
 }
-export declare namespace signer { }
 export declare namespace string_ {
     interface String {
         bytes: string;
@@ -595,8 +711,11 @@ export declare namespace string_ {
         const TYPE_QNAME = "0x1::string::String";
         function type(): TypeDescriptor<String>;
     }
+    namespace view { }
+}
+export declare namespace vector {
+    namespace view { }
 }
-export declare namespace vector { }
 export declare namespace voting {
     interface CreateProposalEvent {
         proposal_id: bigint;
@@ -689,6 +808,52 @@ export declare namespace voting {
         const TYPE_QNAME = "0x1::voting::VotingForum";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VotingForum<T0>>;
     }
+    namespace view {
+        function getEarlyResolutionVoteThreshold<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function getExecutionHash<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[string]>;
+        function getMinVoteThreshold<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalCreationSecs<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalExpirationSecs<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalState<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getVotes<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint, bigint]>;
+        function isMultiStepProposalInExecution<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isResolved<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isVotingClosed<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function nextProposalId<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+    }
 }
 export declare namespace account {
     interface Account {
@@ -800,6 +965,32 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
         function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
     }
+    namespace view {
+        function existsAt(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function getAuthenticationKey(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[string]>;
+        function getGuidNextCreationNum(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getSequenceNumber(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getSignerCapabilityOfferFor(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function isSignerCapabilityOffered(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
 }
 export declare namespace ed25519 {
     interface Signature {
@@ -831,6 +1022,7 @@ export declare namespace ed25519 {
         const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    namespace view { }
 }
 export declare namespace genesis {
     interface AccountMap {
@@ -875,8 +1067,11 @@ export declare namespace genesis {
         const TYPE_QNAME = "0x1::genesis::ValidatorConfigurationWithCommission";
         function type(): TypeDescriptor<ValidatorConfigurationWithCommission>;
     }
+    namespace view { }
+}
+export declare namespace math128 {
+    namespace view { }
 }
-export declare namespace math128 { }
 export declare namespace version {
     interface SetVersionCapability {
         dummy_field: Boolean;
@@ -892,6 +1087,7 @@ export declare namespace version {
         const TYPE_QNAME = "0x1::version::Version";
         function type(): TypeDescriptor<Version>;
     }
+    namespace view { }
 }
 export declare namespace vesting {
     interface AdminStore {
@@ -1098,6 +1294,64 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::VestingSchedule";
         function type(): TypeDescriptor<VestingSchedule>;
     }
+    namespace view {
+        function accumulatedRewards(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function beneficiary(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function operator(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function operatorCommissionPercentage(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function periodDurationSecs(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function remainingGrant(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function shareholder(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function shareholders(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address[]]>;
+        function stakePoolAddress(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function totalAccumulatedRewards(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function vestingContracts(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address[]]>;
+        function vestingSchedule(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[vesting.VestingSchedule]>;
+        function vestingStartSecs(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function voter(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+    }
 }
 export declare namespace bls12381 {
     interface AggrOrMultiSignature {
@@ -1142,6 +1396,7 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::Signature";
         function type(): TypeDescriptor<Signature>;
     }
+    namespace view { }
 }
 export declare namespace chain_id {
     interface ChainId {
@@ -1151,6 +1406,12 @@ export declare namespace chain_id {
         const TYPE_QNAME = "0x1::chain_id::ChainId";
         function type(): TypeDescriptor<ChainId>;
     }
+    namespace view {
+        function get(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[number]>;
+    }
 }
 export declare namespace features {
     interface Features {
@@ -1160,8 +1421,11 @@ export declare namespace features {
         const TYPE_QNAME = "0x1::features::Features";
         function type(): TypeDescriptor<Features>;
     }
+    namespace view { }
+}
+export declare namespace from_bcs {
+    namespace view { }
 }
-export declare namespace from_bcs { }
 export declare namespace pool_u64 {
     interface Pool {
         shareholders_limit: bigint;
@@ -1175,6 +1439,7 @@ export declare namespace pool_u64 {
         const TYPE_QNAME = "0x1::pool_u64::Pool";
         function type(): TypeDescriptor<Pool>;
     }
+    namespace view { }
 }
 export declare namespace secp256k1 {
     interface ECDSARawPublicKey {
@@ -1191,6 +1456,7 @@ export declare namespace secp256k1 {
         const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
         function type(): TypeDescriptor<ECDSASignature>;
     }
+    namespace view { }
 }
 export declare namespace timestamp {
     interface CurrentTimeMicroseconds {
@@ -1200,6 +1466,16 @@ export declare namespace timestamp {
         const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
         function type(): TypeDescriptor<CurrentTimeMicroseconds>;
     }
+    namespace view {
+        function nowMicroseconds(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+        function nowSeconds(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+    }
 }
 export declare namespace type_info {
     interface TypeInfo {
@@ -1211,6 +1487,7 @@ export declare namespace type_info {
         const TYPE_QNAME = "0x1::type_info::TypeInfo";
         function type(): TypeDescriptor<TypeInfo>;
     }
+    namespace view { }
 }
 export declare namespace aggregator {
     interface Aggregator {
@@ -1222,6 +1499,7 @@ export declare namespace aggregator {
         const TYPE_QNAME = "0x1::aggregator::Aggregator";
         function type(): TypeDescriptor<Aggregator>;
     }
+    namespace view { }
 }
 export declare namespace aptos_coin {
     interface AptosCoin {
@@ -1252,8 +1530,11 @@ export declare namespace aptos_coin {
         const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
         function type(): TypeDescriptor<MintCapStore>;
     }
+    namespace view { }
+}
+export declare namespace aptos_hash {
+    namespace view { }
 }
-export declare namespace aptos_hash { }
 export declare namespace big_vector {
     interface BigVector<T0> {
         buckets: table_with_length.TableWithLength<bigint, T0[] | string>;
@@ -1264,6 +1545,7 @@ export declare namespace big_vector {
         const TYPE_QNAME = "0x1::big_vector::BigVector";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BigVector<T0>>;
     }
+    namespace view { }
 }
 export declare namespace bit_vector {
     interface BitVector {
@@ -1274,6 +1556,7 @@ export declare namespace bit_vector {
         const TYPE_QNAME = "0x1::bit_vector::BitVector";
         function type(): TypeDescriptor<BitVector>;
     }
+    namespace view { }
 }
 export declare namespace capability {
     interface Cap<T0> {
@@ -1304,6 +1587,7 @@ export declare namespace capability {
         const TYPE_QNAME = "0x1::capability::LinearCap";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<LinearCap<T0>>;
     }
+    namespace view { }
 }
 export declare namespace comparator {
     interface Result {
@@ -1313,8 +1597,11 @@ export declare namespace comparator {
         const TYPE_QNAME = "0x1::comparator::Result";
         function type(): TypeDescriptor<Result>;
     }
+    namespace view { }
+}
+export declare namespace math_fixed {
+    namespace view { }
 }
-export declare namespace math_fixed { }
 export declare namespace simple_map {
     interface Element<T0, T1> {
         key: T0;
@@ -1331,6 +1618,7 @@ export declare namespace simple_map {
         const TYPE_QNAME = "0x1::simple_map::SimpleMap";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SimpleMap<T0, T1>>;
     }
+    namespace view { }
 }
 export declare namespace smart_table {
     interface Entry<T0, T1> {
@@ -1354,6 +1642,7 @@ export declare namespace smart_table {
         const TYPE_QNAME = "0x1::smart_table::SmartTable";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SmartTable<T0, T1>>;
     }
+    namespace view { }
 }
 export declare namespace storage_gas {
     interface GasCurve {
@@ -1403,6 +1692,7 @@ export declare namespace storage_gas {
         const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
         function type(): TypeDescriptor<UsageGasConfig>;
     }
+    namespace view { }
 }
 export declare namespace chain_status {
     interface GenesisEndMarker {
@@ -1412,6 +1702,16 @@ export declare namespace chain_status {
         const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
         function type(): TypeDescriptor<GenesisEndMarker>;
     }
+    namespace view {
+        function isGenesis(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isOperating(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
 }
 export declare namespace copyable_any {
     interface Any {
@@ -1422,6 +1722,7 @@ export declare namespace copyable_any {
         const TYPE_QNAME = "0x1::copyable_any::Any";
         function type(): TypeDescriptor<Any>;
     }
+    namespace view { }
 }
 export declare namespace gas_schedule {
     interface GasEntry {
@@ -1447,6 +1748,7 @@ export declare namespace gas_schedule {
         const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
         function type(): TypeDescriptor<GasScheduleV2>;
     }
+    namespace view { }
 }
 export declare namespace managed_coin {
     interface Capabilities<T0> {
@@ -1458,6 +1760,10 @@ export declare namespace managed_coin {
         const TYPE_QNAME = "0x1::managed_coin::Capabilities";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
     }
+    namespace view { }
+}
+export declare namespace math_fixed64 {
+    namespace view { }
 }
 export declare namespace ristretto255 {
     interface CompressedRistretto {
@@ -1481,11 +1787,12 @@ export declare namespace ristretto255 {
         const TYPE_QNAME = "0x1::ristretto255::Scalar";
         function type(): TypeDescriptor<Scalar>;
     }
+    namespace view { }
 }
 export declare namespace smart_vector {
     interface SmartVector<T0> {
         inline_vec: T0[] | string;
-        big_vec: big_vector.BigVector<T0>[];
+        big_vec: option.Option<big_vector.BigVector<T0>>;
         inline_capacity: option.Option<bigint>;
         bucket_size: option.Option<bigint>;
     }
@@ -1493,6 +1800,33 @@ export declare namespace smart_vector {
         const TYPE_QNAME = "0x1::smart_vector::SmartVector";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
     }
+    namespace view { }
+}
+export declare namespace string_utils {
+    interface Cons<T0, T1> {
+        car: T0;
+        cdr: T1;
+    }
+    namespace Cons {
+        const TYPE_QNAME = "0x1::string_utils::Cons";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Cons<T0, T1>>;
+    }
+    interface FakeCons<T0, T1> {
+        car: T0;
+        cdr: T1;
+    }
+    namespace FakeCons {
+        const TYPE_QNAME = "0x1::string_utils::FakeCons";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<FakeCons<T0, T1>>;
+    }
+    interface NIL {
+        dummy_field: Boolean;
+    }
+    namespace NIL {
+        const TYPE_QNAME = "0x1::string_utils::NIL";
+        function type(): TypeDescriptor<NIL>;
+    }
+    namespace view { }
 }
 export declare namespace aptos_account {
     interface DirectCoinTransferConfigUpdatedEvent {
@@ -1514,8 +1848,16 @@ export declare namespace aptos_account {
         const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
         function type(): TypeDescriptor<DirectTransferConfig>;
     }
+    namespace view {
+        function canReceiveDirectCoinTransfers(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace create_signer {
+    namespace view { }
 }
-export declare namespace create_signer { }
 export declare namespace fixed_point32 {
     interface FixedPoint32 {
         value: bigint;
@@ -1524,6 +1866,17 @@ export declare namespace fixed_point32 {
         const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
         function type(): TypeDescriptor<FixedPoint32>;
     }
+    namespace view { }
+}
+export declare namespace fixed_point64 {
+    interface FixedPoint64 {
+        value: bigint;
+    }
+    namespace FixedPoint64 {
+        const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
+        function type(): TypeDescriptor<FixedPoint64>;
+    }
+    namespace view { }
 }
 export declare namespace multi_ed25519 {
     interface Signature {
@@ -1547,8 +1900,11 @@ export declare namespace multi_ed25519 {
         const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    namespace view { }
+}
+export declare namespace staking_proxy {
+    namespace view { }
 }
-export declare namespace staking_proxy { }
 export declare namespace state_storage {
     interface GasParameter {
         usage: state_storage.Usage;
@@ -1573,6 +1929,156 @@ export declare namespace state_storage {
         const TYPE_QNAME = "0x1::state_storage::Usage";
         function type(): TypeDescriptor<Usage>;
     }
+    namespace view { }
+}
+export declare namespace crypto_algebra {
+    interface Element<T0> {
+        handle: bigint;
+    }
+    namespace Element {
+        const TYPE_QNAME = "0x1::crypto_algebra::Element";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Element<T0>>;
+    }
+    namespace view { }
+}
+export declare namespace fungible_asset {
+    interface BurnRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace BurnRef {
+        const TYPE_QNAME = "0x1::fungible_asset::BurnRef";
+        function type(): TypeDescriptor<BurnRef>;
+    }
+    interface DepositEvent {
+        amount: bigint;
+    }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+        data_decoded: DepositEvent;
+        type_arguments: [];
+    }
+    interface FrozenEvent {
+        frozen: Boolean;
+    }
+    namespace FrozenEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::FrozenEvent";
+        function type(): TypeDescriptor<FrozenEvent>;
+    }
+    interface FrozenEventInstance extends TypedEventInstance<FrozenEvent> {
+        data_decoded: FrozenEvent;
+        type_arguments: [];
+    }
+    interface FungibleAsset {
+        metadata: object_.Object<fungible_asset.Metadata>;
+        amount: bigint;
+    }
+    namespace FungibleAsset {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleAsset";
+        function type(): TypeDescriptor<FungibleAsset>;
+    }
+    interface FungibleAssetEvents {
+        deposit_events: event.EventHandle<fungible_asset.DepositEvent>;
+        withdraw_events: event.EventHandle<fungible_asset.WithdrawEvent>;
+        frozen_events: event.EventHandle<fungible_asset.FrozenEvent>;
+    }
+    namespace FungibleAssetEvents {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleAssetEvents";
+        function type(): TypeDescriptor<FungibleAssetEvents>;
+    }
+    interface FungibleStore {
+        metadata: object_.Object<fungible_asset.Metadata>;
+        balance: bigint;
+        frozen: Boolean;
+    }
+    namespace FungibleStore {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleStore";
+        function type(): TypeDescriptor<FungibleStore>;
+    }
+    interface Metadata {
+        name: string;
+        symbol: string;
+        decimals: number;
+        icon_uri: string;
+        project_uri: string;
+    }
+    namespace Metadata {
+        const TYPE_QNAME = "0x1::fungible_asset::Metadata";
+        function type(): TypeDescriptor<Metadata>;
+    }
+    interface MintRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace MintRef {
+        const TYPE_QNAME = "0x1::fungible_asset::MintRef";
+        function type(): TypeDescriptor<MintRef>;
+    }
+    interface Supply {
+        current: bigint;
+        maximum: option.Option<bigint>;
+    }
+    namespace Supply {
+        const TYPE_QNAME = "0x1::fungible_asset::Supply";
+        function type(): TypeDescriptor<Supply>;
+    }
+    interface TransferRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace TransferRef {
+        const TYPE_QNAME = "0x1::fungible_asset::TransferRef";
+        function type(): TypeDescriptor<TransferRef>;
+    }
+    interface WithdrawEvent {
+        amount: bigint;
+    }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
+    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
+        data_decoded: WithdrawEvent;
+        type_arguments: [];
+    }
+    namespace view {
+        function balance<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function decimals<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[number]>;
+        function isFrozen<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+        function maximum<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function name<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function storeExists(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function storeMetadata<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[object_.Object<fungible_asset.Metadata>]>;
+        function supply<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function symbol<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+    }
 }
 export declare namespace staking_config {
     interface StakingConfig {
@@ -1588,6 +2094,18 @@ export declare namespace staking_config {
         const TYPE_QNAME = "0x1::staking_config::StakingConfig";
         function type(): TypeDescriptor<StakingConfig>;
     }
+    interface StakingRewardsConfig {
+        rewards_rate: fixed_point64.FixedPoint64;
+        min_rewards_rate: fixed_point64.FixedPoint64;
+        rewards_rate_period_in_secs: bigint;
+        last_rewards_rate_period_start_in_secs: bigint;
+        rewards_rate_decrease_rate: fixed_point64.FixedPoint64;
+    }
+    namespace StakingRewardsConfig {
+        const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";
+        function type(): TypeDescriptor<StakingRewardsConfig>;
+    }
+    namespace view { }
 }
 export declare namespace delegation_pool {
     interface AddStakeEvent {
@@ -1689,6 +2207,52 @@ export declare namespace delegation_pool {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
     }
+    namespace view {
+        function canWithdrawPendingInactive(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function delegationPoolExists(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function getAddStakeFee(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getDelegationPoolStake(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getOwnedPoolAddress(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getPendingWithdrawal(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Boolean, bigint]>;
+        function getStake(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function observedLockupCycle(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function operatorCommissionPercentage(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function ownerCapExists(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function shareholdersCountActivePool(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+    }
 }
 export declare namespace reconfiguration {
     interface Configuration {
@@ -1718,6 +2282,7 @@ export declare namespace reconfiguration {
         data_decoded: NewEpochEvent;
         type_arguments: [];
     }
+    namespace view { }
 }
 export declare namespace transaction_fee {
     interface AptosCoinCapabilities {
@@ -1736,6 +2301,7 @@ export declare namespace transaction_fee {
         const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
         function type(): TypeDescriptor<CollectedFeesPerBlock>;
     }
+    namespace view { }
 }
 export declare namespace aptos_governance {
     interface ApprovedExecutionHashes {
@@ -1828,6 +2394,128 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
         function type(): TypeDescriptor<VotingRecords>;
     }
+    namespace view {
+        function getMinVotingThreshold(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+        function getRequiredProposerStake(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+        function getVotingDurationSecs(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [];
+        }, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace bls12381_algebra {
+    interface FormatFq12LscLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFq12LscLsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFq12LscLsb";
+        function type(): TypeDescriptor<FormatFq12LscLsb>;
+    }
+    interface FormatFrLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrLsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrLsb";
+        function type(): TypeDescriptor<FormatFrLsb>;
+    }
+    interface FormatFrMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrMsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrMsb";
+        function type(): TypeDescriptor<FormatFrMsb>;
+    }
+    interface FormatG1Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Compr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Compr";
+        function type(): TypeDescriptor<FormatG1Compr>;
+    }
+    interface FormatG1Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Uncompr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Uncompr";
+        function type(): TypeDescriptor<FormatG1Uncompr>;
+    }
+    interface FormatG2Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Compr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Compr";
+        function type(): TypeDescriptor<FormatG2Compr>;
+    }
+    interface FormatG2Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Uncompr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Uncompr";
+        function type(): TypeDescriptor<FormatG2Uncompr>;
+    }
+    interface FormatGt {
+        dummy_field: Boolean;
+    }
+    namespace FormatGt {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatGt";
+        function type(): TypeDescriptor<FormatGt>;
+    }
+    interface Fq12 {
+        dummy_field: Boolean;
+    }
+    namespace Fq12 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Fq12";
+        function type(): TypeDescriptor<Fq12>;
+    }
+    interface Fr {
+        dummy_field: Boolean;
+    }
+    namespace Fr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Fr";
+        function type(): TypeDescriptor<Fr>;
+    }
+    interface G1 {
+        dummy_field: Boolean;
+    }
+    namespace G1 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::G1";
+        function type(): TypeDescriptor<G1>;
+    }
+    interface G2 {
+        dummy_field: Boolean;
+    }
+    namespace G2 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::G2";
+        function type(): TypeDescriptor<G2>;
+    }
+    interface Gt {
+        dummy_field: Boolean;
+    }
+    namespace Gt {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Gt";
+        function type(): TypeDescriptor<Gt>;
+    }
+    interface HashG1XmdSha256SswuRo {
+        dummy_field: Boolean;
+    }
+    namespace HashG1XmdSha256SswuRo {
+        const TYPE_QNAME = "0x1::bls12381_algebra::HashG1XmdSha256SswuRo";
+        function type(): TypeDescriptor<HashG1XmdSha256SswuRo>;
+    }
+    interface HashG2XmdSha256SswuRo {
+        dummy_field: Boolean;
+    }
+    namespace HashG2XmdSha256SswuRo {
+        const TYPE_QNAME = "0x1::bls12381_algebra::HashG2XmdSha256SswuRo";
+        function type(): TypeDescriptor<HashG2XmdSha256SswuRo>;
+    }
+    namespace view { }
 }
 export declare namespace consensus_config {
     interface ConsensusConfig {
@@ -1837,6 +2525,17 @@ export declare namespace consensus_config {
         const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
         function type(): TypeDescriptor<ConsensusConfig>;
     }
+    namespace view { }
+}
+export declare namespace execution_config {
+    interface ExecutionConfig {
+        config: string;
+    }
+    namespace ExecutionConfig {
+        const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
+        function type(): TypeDescriptor<ExecutionConfig>;
+    }
+    namespace view { }
 }
 export declare namespace multisig_account {
     interface AddOwnersEvent {
@@ -2006,6 +2705,56 @@ export declare namespace multisig_account {
         data_decoded: VoteEvent;
         type_arguments: [];
     }
+    namespace view {
+        function canBeExecuted(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function canBeRejected(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function getNextMultisigAccountAddress(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getNextTransactionPayload(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, string];
+        }, version?: bigint): Promise<[string]>;
+        function getPendingTransactions(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[multisig_account.MultisigTransaction[]]>;
+        function getTransaction(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
+        function lastResolvedSequenceNumber(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function metadata(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function nextSequenceNumber(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function numSignaturesRequired(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function owners(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address[]]>;
+        function vote(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, Address];
+        }, version?: bigint): Promise<[Boolean, Boolean]>;
+    }
 }
 export declare namespace pool_u64_unbound {
     interface Pool {
@@ -2018,6 +2767,7 @@ export declare namespace pool_u64_unbound {
         const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
         function type(): TypeDescriptor<Pool>;
     }
+    namespace view { }
 }
 export declare namespace resource_account {
     interface Container {
@@ -2027,6 +2777,7 @@ export declare namespace resource_account {
         const TYPE_QNAME = "0x1::resource_account::Container";
         function type(): TypeDescriptor<Container>;
     }
+    namespace view { }
 }
 export declare namespace staking_contract {
     interface AddDistributionEvent {
@@ -2207,8 +2958,36 @@ export declare namespace staking_contract {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
     }
+    namespace view {
+        function commissionPercentage(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function lastRecordedPrincipal(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function pendingDistributionCounts(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function stakePoolAddress(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function stakingContractAmounts(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function stakingContractExists(client: AptosClient, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace system_addresses {
+    namespace view { }
 }
-export declare namespace system_addresses { }
 export declare namespace table_with_length {
     interface TableWithLength<T0, T1> {
         inner: table.Table<T0, T1>;
@@ -2218,6 +2997,7 @@ export declare namespace table_with_length {
         const TYPE_QNAME = "0x1::table_with_length::TableWithLength";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<TableWithLength<T0, T1>>;
     }
+    namespace view { }
 }
 export declare namespace aggregator_factory {
     interface AggregatorFactory {
@@ -2227,6 +3007,7 @@ export declare namespace aggregator_factory {
         const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
         function type(): TypeDescriptor<AggregatorFactory>;
     }
+    namespace view { }
 }
 export declare namespace governance_proposal {
     interface GovernanceProposal {
@@ -2236,6 +3017,7 @@ export declare namespace governance_proposal {
         const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
         function type(): TypeDescriptor<GovernanceProposal>;
     }
+    namespace view { }
 }
 export declare namespace optional_aggregator {
     interface Integer {
@@ -2254,8 +3036,42 @@ export declare namespace optional_aggregator {
         const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
         function type(): TypeDescriptor<OptionalAggregator>;
     }
+    namespace view { }
+}
+export declare namespace transaction_context {
+    namespace view { }
+}
+export declare namespace primary_fungible_store {
+    interface DeriveRefPod {
+        metadata_derive_ref: object_.DeriveRef;
+    }
+    namespace DeriveRefPod {
+        const TYPE_QNAME = "0x1::primary_fungible_store::DeriveRefPod";
+        function type(): TypeDescriptor<DeriveRefPod>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function isFrozen<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+        function primaryStore<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[object_.Object<fungible_asset.FungibleStore>]>;
+        function primaryStoreAddress<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[Address]>;
+        function primaryStoreExists<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
 }
-export declare namespace transaction_context { }
 export declare namespace transaction_validation {
     interface TransactionValidation {
         module_addr: Address;
@@ -2269,6 +3085,7 @@ export declare namespace transaction_validation {
         const TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
         function type(): TypeDescriptor<TransactionValidation>;
     }
+    namespace view { }
 }
 export declare function loadAllTypes(coder: MoveCoder): void;
 //# sourceMappingURL=0x1.d.ts.map