@sentio/sdk 2.13.0-rc.6 → 2.13.0-rc.8

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

@@ -1,4 +1,4 @@
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor } from "@sentio/sdk/move";
 import { MoveCoder, AptosBindOptions, AptosBaseProcessor, TypedEventInstance, TypedFunctionPayload, AptosContext } from "@sentio/sdk/aptos";
 import { MoveFetchConfig } from "@sentio/protos";
 import { Address } from "@sentio/sdk/aptos";
@@ -26,17 +26,19 @@ export declare class token extends AptosBaseProcessor {
     onEventMutateTokenPropertyMapEvent(func: (event: token.MutateTokenPropertyMapEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
 }
 export declare namespace token {
-    class BurnTokenEvent {
-        static TYPE_QNAME: string;
+    interface BurnTokenEvent {
         id: token.TokenId;
         amount: bigint;
     }
+    namespace BurnTokenEvent {
+        const TYPE_QNAME = "0x3::token::BurnTokenEvent";
+        function type(): TypeDescriptor<BurnTokenEvent>;
+    }
     interface BurnTokenEventInstance extends TypedEventInstance<BurnTokenEvent> {
         data_decoded: BurnTokenEvent;
         type_arguments: [];
     }
-    class CollectionData {
-        static TYPE_QNAME: string;
+    interface CollectionData {
         description: string;
         name: string;
         uri: string;
@@ -44,34 +46,46 @@ export declare namespace token {
         maximum: bigint;
         mutability_config: token.CollectionMutabilityConfig;
     }
-    class CollectionMutabilityConfig {
-        static TYPE_QNAME: string;
+    namespace CollectionData {
+        const TYPE_QNAME = "0x3::token::CollectionData";
+        function type(): TypeDescriptor<CollectionData>;
+    }
+    interface CollectionMutabilityConfig {
         description: Boolean;
         uri: Boolean;
         maximum: Boolean;
     }
-    class Collections {
-        static TYPE_QNAME: string;
+    namespace CollectionMutabilityConfig {
+        const TYPE_QNAME = "0x3::token::CollectionMutabilityConfig";
+        function type(): TypeDescriptor<CollectionMutabilityConfig>;
+    }
+    interface Collections {
         collection_data: _0x1.table.Table<string, token.CollectionData>;
         token_data: _0x1.table.Table<token.TokenDataId, token.TokenData>;
         create_collection_events: _0x1.event.EventHandle<token.CreateCollectionEvent>;
         create_token_data_events: _0x1.event.EventHandle<token.CreateTokenDataEvent>;
         mint_token_events: _0x1.event.EventHandle<token.MintTokenEvent>;
     }
-    class CreateCollectionEvent {
-        static TYPE_QNAME: string;
+    namespace Collections {
+        const TYPE_QNAME = "0x3::token::Collections";
+        function type(): TypeDescriptor<Collections>;
+    }
+    interface CreateCollectionEvent {
         creator: Address;
         collection_name: string;
         uri: string;
         description: string;
         maximum: bigint;
     }
+    namespace CreateCollectionEvent {
+        const TYPE_QNAME = "0x3::token::CreateCollectionEvent";
+        function type(): TypeDescriptor<CreateCollectionEvent>;
+    }
     interface CreateCollectionEventInstance extends TypedEventInstance<CreateCollectionEvent> {
         data_decoded: CreateCollectionEvent;
         type_arguments: [];
     }
-    class CreateTokenDataEvent {
-        static TYPE_QNAME: string;
+    interface CreateTokenDataEvent {
         id: token.TokenDataId;
         description: string;
         maximum: bigint;
@@ -85,54 +99,72 @@ export declare namespace token {
         property_values: string[];
         property_types: string[];
     }
+    namespace CreateTokenDataEvent {
+        const TYPE_QNAME = "0x3::token::CreateTokenDataEvent";
+        function type(): TypeDescriptor<CreateTokenDataEvent>;
+    }
     interface CreateTokenDataEventInstance extends TypedEventInstance<CreateTokenDataEvent> {
         data_decoded: CreateTokenDataEvent;
         type_arguments: [];
     }
-    class DepositEvent {
-        static TYPE_QNAME: string;
+    interface DepositEvent {
         id: token.TokenId;
         amount: bigint;
     }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x3::token::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
     interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
         data_decoded: DepositEvent;
         type_arguments: [];
     }
-    class MintTokenEvent {
-        static TYPE_QNAME: string;
+    interface MintTokenEvent {
         id: token.TokenDataId;
         amount: bigint;
     }
+    namespace MintTokenEvent {
+        const TYPE_QNAME = "0x3::token::MintTokenEvent";
+        function type(): TypeDescriptor<MintTokenEvent>;
+    }
     interface MintTokenEventInstance extends TypedEventInstance<MintTokenEvent> {
         data_decoded: MintTokenEvent;
         type_arguments: [];
     }
-    class MutateTokenPropertyMapEvent {
-        static TYPE_QNAME: string;
+    interface MutateTokenPropertyMapEvent {
         old_id: token.TokenId;
         new_id: token.TokenId;
         keys: string[];
         values: string[];
         types: string[];
     }
+    namespace MutateTokenPropertyMapEvent {
+        const TYPE_QNAME = "0x3::token::MutateTokenPropertyMapEvent";
+        function type(): TypeDescriptor<MutateTokenPropertyMapEvent>;
+    }
     interface MutateTokenPropertyMapEventInstance extends TypedEventInstance<MutateTokenPropertyMapEvent> {
         data_decoded: MutateTokenPropertyMapEvent;
         type_arguments: [];
     }
-    class Royalty {
-        static TYPE_QNAME: string;
+    interface Royalty {
         royalty_points_numerator: bigint;
         royalty_points_denominator: bigint;
         payee_address: Address;
     }
-    class Token {
-        static TYPE_QNAME: string;
+    namespace Royalty {
+        const TYPE_QNAME = "0x3::token::Royalty";
+        function type(): TypeDescriptor<Royalty>;
+    }
+    interface Token {
         id: token.TokenId;
         amount: bigint;
         token_properties: property_map.PropertyMap;
     }
-    class TokenData {
-        static TYPE_QNAME: string;
+    namespace Token {
+        const TYPE_QNAME = "0x3::token::Token";
+        function type(): TypeDescriptor<Token>;
+    }
+    interface TokenData {
         maximum: bigint;
         largest_property_version: bigint;
         supply: bigint;
@@ -143,27 +175,39 @@ export declare namespace token {
         default_properties: property_map.PropertyMap;
         mutability_config: token.TokenMutabilityConfig;
     }
-    class TokenDataId {
-        static TYPE_QNAME: string;
+    namespace TokenData {
+        const TYPE_QNAME = "0x3::token::TokenData";
+        function type(): TypeDescriptor<TokenData>;
+    }
+    interface TokenDataId {
         creator: Address;
         collection: string;
         name: string;
     }
-    class TokenId {
-        static TYPE_QNAME: string;
+    namespace TokenDataId {
+        const TYPE_QNAME = "0x3::token::TokenDataId";
+        function type(): TypeDescriptor<TokenDataId>;
+    }
+    interface TokenId {
         token_data_id: token.TokenDataId;
         property_version: bigint;
     }
-    class TokenMutabilityConfig {
-        static TYPE_QNAME: string;
+    namespace TokenId {
+        const TYPE_QNAME = "0x3::token::TokenId";
+        function type(): TypeDescriptor<TokenId>;
+    }
+    interface TokenMutabilityConfig {
         maximum: Boolean;
         uri: Boolean;
         royalty: Boolean;
         description: Boolean;
         properties: Boolean;
     }
-    class TokenStore {
-        static TYPE_QNAME: string;
+    namespace TokenMutabilityConfig {
+        const TYPE_QNAME = "0x3::token::TokenMutabilityConfig";
+        function type(): TypeDescriptor<TokenMutabilityConfig>;
+    }
+    interface TokenStore {
         tokens: _0x1.table.Table<token.TokenId, token.Token>;
         direct_transfer: Boolean;
         deposit_events: _0x1.event.EventHandle<token.DepositEvent>;
@@ -171,18 +215,28 @@ export declare namespace token {
         burn_events: _0x1.event.EventHandle<token.BurnTokenEvent>;
         mutate_token_property_events: _0x1.event.EventHandle<token.MutateTokenPropertyMapEvent>;
     }
-    class WithdrawCapability {
-        static TYPE_QNAME: string;
+    namespace TokenStore {
+        const TYPE_QNAME = "0x3::token::TokenStore";
+        function type(): TypeDescriptor<TokenStore>;
+    }
+    interface WithdrawCapability {
         token_owner: Address;
         token_id: token.TokenId;
         amount: bigint;
         expiration_sec: bigint;
     }
-    class WithdrawEvent {
-        static TYPE_QNAME: string;
+    namespace WithdrawCapability {
+        const TYPE_QNAME = "0x3::token::WithdrawCapability";
+        function type(): TypeDescriptor<WithdrawCapability>;
+    }
+    interface WithdrawEvent {
         id: token.TokenId;
         amount: bigint;
     }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x3::token::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
     interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
         data_decoded: WithdrawEvent;
         type_arguments: [];
@@ -291,15 +345,21 @@ export declare namespace token {
     }
 }
 export declare namespace property_map {
-    class PropertyMap {
-        static TYPE_QNAME: string;
+    interface PropertyMap {
         map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
     }
-    class PropertyValue {
-        static TYPE_QNAME: string;
+    namespace PropertyMap {
+        const TYPE_QNAME = "0x3::property_map::PropertyMap";
+        function type(): TypeDescriptor<PropertyMap>;
+    }
+    interface PropertyValue {
         value: string;
         type: string;
     }
+    namespace PropertyValue {
+        const TYPE_QNAME = "0x3::property_map::PropertyValue";
+        function type(): TypeDescriptor<PropertyValue>;
+    }
 }
 export declare class token_coin_swap extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -310,46 +370,64 @@ export declare class token_coin_swap extends AptosBaseProcessor {
     onEventTokenSwapEvent(func: (event: token_coin_swap.TokenSwapEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_coin_swap;
 }
 export declare namespace token_coin_swap {
-    class TokenCoinSwap<T0> {
-        static TYPE_QNAME: string;
+    interface TokenCoinSwap<T0> {
         token_amount: bigint;
         min_price_per_token: bigint;
     }
-    class TokenEscrow {
-        static TYPE_QNAME: string;
+    namespace TokenCoinSwap {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenCoinSwap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TokenCoinSwap<T0>>;
+    }
+    interface TokenEscrow {
         token: token.Token;
         locked_until_secs: bigint;
     }
-    class TokenListingEvent {
-        static TYPE_QNAME: string;
+    namespace TokenEscrow {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenEscrow";
+        function type(): TypeDescriptor<TokenEscrow>;
+    }
+    interface TokenListingEvent {
         token_id: token.TokenId;
         amount: bigint;
         min_price: bigint;
         locked_until_secs: bigint;
         coin_type_info: _0x1.type_info.TypeInfo;
     }
+    namespace TokenListingEvent {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenListingEvent";
+        function type(): TypeDescriptor<TokenListingEvent>;
+    }
     interface TokenListingEventInstance extends TypedEventInstance<TokenListingEvent> {
         data_decoded: TokenListingEvent;
         type_arguments: [];
     }
-    class TokenListings<T0> {
-        static TYPE_QNAME: string;
+    interface TokenListings<T0> {
         listings: _0x1.table.Table<token.TokenId, token_coin_swap.TokenCoinSwap<T0>>;
         listing_events: _0x1.event.EventHandle<token_coin_swap.TokenListingEvent>;
         swap_events: _0x1.event.EventHandle<token_coin_swap.TokenSwapEvent>;
     }
-    class TokenStoreEscrow {
-        static TYPE_QNAME: string;
+    namespace TokenListings {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenListings";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TokenListings<T0>>;
+    }
+    interface TokenStoreEscrow {
         token_escrows: _0x1.table.Table<token.TokenId, token_coin_swap.TokenEscrow>;
     }
-    class TokenSwapEvent {
-        static TYPE_QNAME: string;
+    namespace TokenStoreEscrow {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenStoreEscrow";
+        function type(): TypeDescriptor<TokenStoreEscrow>;
+    }
+    interface TokenSwapEvent {
         token_id: token.TokenId;
         token_buyer: Address;
         token_amount: bigint;
         coin_amount: bigint;
         coin_type_info: _0x1.type_info.TypeInfo;
     }
+    namespace TokenSwapEvent {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenSwapEvent";
+        function type(): TypeDescriptor<TokenSwapEvent>;
+    }
     interface TokenSwapEventInstance extends TypedEventInstance<TokenSwapEvent> {
         data_decoded: TokenSwapEvent;
         type_arguments: [];
@@ -387,48 +465,63 @@ export declare class token_transfers extends AptosBaseProcessor {
     onEventTokenClaimEvent(func: (event: token_transfers.TokenClaimEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
 }
 export declare namespace token_transfers {
-    class PendingClaims {
-        static TYPE_QNAME: string;
+    interface PendingClaims {
         pending_claims: _0x1.table.Table<token_transfers.TokenOfferId, token.Token>;
         offer_events: _0x1.event.EventHandle<token_transfers.TokenOfferEvent>;
         cancel_offer_events: _0x1.event.EventHandle<token_transfers.TokenCancelOfferEvent>;
         claim_events: _0x1.event.EventHandle<token_transfers.TokenClaimEvent>;
     }
-    class TokenCancelOfferEvent {
-        static TYPE_QNAME: string;
+    namespace PendingClaims {
+        const TYPE_QNAME = "0x3::token_transfers::PendingClaims";
+        function type(): TypeDescriptor<PendingClaims>;
+    }
+    interface TokenCancelOfferEvent {
         to_address: Address;
         token_id: token.TokenId;
         amount: bigint;
     }
+    namespace TokenCancelOfferEvent {
+        const TYPE_QNAME = "0x3::token_transfers::TokenCancelOfferEvent";
+        function type(): TypeDescriptor<TokenCancelOfferEvent>;
+    }
     interface TokenCancelOfferEventInstance extends TypedEventInstance<TokenCancelOfferEvent> {
         data_decoded: TokenCancelOfferEvent;
         type_arguments: [];
     }
-    class TokenClaimEvent {
-        static TYPE_QNAME: string;
+    interface TokenClaimEvent {
         to_address: Address;
         token_id: token.TokenId;
         amount: bigint;
     }
+    namespace TokenClaimEvent {
+        const TYPE_QNAME = "0x3::token_transfers::TokenClaimEvent";
+        function type(): TypeDescriptor<TokenClaimEvent>;
+    }
     interface TokenClaimEventInstance extends TypedEventInstance<TokenClaimEvent> {
         data_decoded: TokenClaimEvent;
         type_arguments: [];
     }
-    class TokenOfferEvent {
-        static TYPE_QNAME: string;
+    interface TokenOfferEvent {
         to_address: Address;
         token_id: token.TokenId;
         amount: bigint;
     }
+    namespace TokenOfferEvent {
+        const TYPE_QNAME = "0x3::token_transfers::TokenOfferEvent";
+        function type(): TypeDescriptor<TokenOfferEvent>;
+    }
     interface TokenOfferEventInstance extends TypedEventInstance<TokenOfferEvent> {
         data_decoded: TokenOfferEvent;
         type_arguments: [];
     }
-    class TokenOfferId {
-        static TYPE_QNAME: string;
+    interface TokenOfferId {
         to_addr: Address;
         token_id: token.TokenId;
     }
+    namespace TokenOfferId {
+        const TYPE_QNAME = "0x3::token_transfers::TokenOfferId";
+        function type(): TypeDescriptor<TokenOfferId>;
+    }
     interface CancelOfferScriptPayload extends TypedFunctionPayload<[
         Address,
         Address,
@@ -487,41 +580,49 @@ export declare class token_event_store extends AptosBaseProcessor {
     onEventMaxiumMutateEvent(func: (event: token_event_store.MaxiumMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
 }
 export declare namespace token_event_store {
-    class CollectionDescriptionMutateEvent {
-        static TYPE_QNAME: string;
+    interface CollectionDescriptionMutateEvent {
         creator_addr: Address;
         collection_name: string;
         old_description: string;
         new_description: string;
     }
+    namespace CollectionDescriptionMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::CollectionDescriptionMutateEvent";
+        function type(): TypeDescriptor<CollectionDescriptionMutateEvent>;
+    }
     interface CollectionDescriptionMutateEventInstance extends TypedEventInstance<CollectionDescriptionMutateEvent> {
         data_decoded: CollectionDescriptionMutateEvent;
         type_arguments: [];
     }
-    class CollectionMaxiumMutateEvent {
-        static TYPE_QNAME: string;
+    interface CollectionMaxiumMutateEvent {
         creator_addr: Address;
         collection_name: string;
         old_maximum: bigint;
         new_maximum: bigint;
     }
+    namespace CollectionMaxiumMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::CollectionMaxiumMutateEvent";
+        function type(): TypeDescriptor<CollectionMaxiumMutateEvent>;
+    }
     interface CollectionMaxiumMutateEventInstance extends TypedEventInstance<CollectionMaxiumMutateEvent> {
         data_decoded: CollectionMaxiumMutateEvent;
         type_arguments: [];
     }
-    class CollectionUriMutateEvent {
-        static TYPE_QNAME: string;
+    interface CollectionUriMutateEvent {
         creator_addr: Address;
         collection_name: string;
         old_uri: string;
         new_uri: string;
     }
+    namespace CollectionUriMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::CollectionUriMutateEvent";
+        function type(): TypeDescriptor<CollectionUriMutateEvent>;
+    }
     interface CollectionUriMutateEventInstance extends TypedEventInstance<CollectionUriMutateEvent> {
         data_decoded: CollectionUriMutateEvent;
         type_arguments: [];
     }
-    class DefaultPropertyMutateEvent {
-        static TYPE_QNAME: string;
+    interface DefaultPropertyMutateEvent {
         creator: Address;
         collection: string;
         token: string;
@@ -529,44 +630,56 @@ export declare namespace token_event_store {
         old_values: _0x1.option.Option<property_map.PropertyValue>[];
         new_values: property_map.PropertyValue[];
     }
+    namespace DefaultPropertyMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::DefaultPropertyMutateEvent";
+        function type(): TypeDescriptor<DefaultPropertyMutateEvent>;
+    }
     interface DefaultPropertyMutateEventInstance extends TypedEventInstance<DefaultPropertyMutateEvent> {
         data_decoded: DefaultPropertyMutateEvent;
         type_arguments: [];
     }
-    class DescriptionMutateEvent {
-        static TYPE_QNAME: string;
+    interface DescriptionMutateEvent {
         creator: Address;
         collection: string;
         token: string;
         old_description: string;
         new_description: string;
     }
+    namespace DescriptionMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::DescriptionMutateEvent";
+        function type(): TypeDescriptor<DescriptionMutateEvent>;
+    }
     interface DescriptionMutateEventInstance extends TypedEventInstance<DescriptionMutateEvent> {
         data_decoded: DescriptionMutateEvent;
         type_arguments: [];
     }
-    class MaxiumMutateEvent {
-        static TYPE_QNAME: string;
+    interface MaxiumMutateEvent {
         creator: Address;
         collection: string;
         token: string;
         old_maximum: bigint;
         new_maximum: bigint;
     }
+    namespace MaxiumMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::MaxiumMutateEvent";
+        function type(): TypeDescriptor<MaxiumMutateEvent>;
+    }
     interface MaxiumMutateEventInstance extends TypedEventInstance<MaxiumMutateEvent> {
         data_decoded: MaxiumMutateEvent;
         type_arguments: [];
     }
-    class OptInTransferEvent {
-        static TYPE_QNAME: string;
+    interface OptInTransferEvent {
         opt_in: Boolean;
     }
+    namespace OptInTransferEvent {
+        const TYPE_QNAME = "0x3::token_event_store::OptInTransferEvent";
+        function type(): TypeDescriptor<OptInTransferEvent>;
+    }
     interface OptInTransferEventInstance extends TypedEventInstance<OptInTransferEvent> {
         data_decoded: OptInTransferEvent;
         type_arguments: [];
     }
-    class RoyaltyMutateEvent {
-        static TYPE_QNAME: string;
+    interface RoyaltyMutateEvent {
         creator: Address;
         collection: string;
         token: string;
@@ -577,12 +690,15 @@ export declare namespace token_event_store {
         new_royalty_denominator: bigint;
         new_royalty_payee_addr: Address;
     }
+    namespace RoyaltyMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::RoyaltyMutateEvent";
+        function type(): TypeDescriptor<RoyaltyMutateEvent>;
+    }
     interface RoyaltyMutateEventInstance extends TypedEventInstance<RoyaltyMutateEvent> {
         data_decoded: RoyaltyMutateEvent;
         type_arguments: [];
     }
-    class TokenEventStoreV1 {
-        static TYPE_QNAME: string;
+    interface TokenEventStoreV1 {
         collection_uri_mutate_events: _0x1.event.EventHandle<token_event_store.CollectionUriMutateEvent>;
         collection_maximum_mutate_events: _0x1.event.EventHandle<token_event_store.CollectionMaxiumMutateEvent>;
         collection_description_mutate_events: _0x1.event.EventHandle<token_event_store.CollectionDescriptionMutateEvent>;
@@ -594,14 +710,21 @@ export declare namespace token_event_store {
         maximum_mutate_events: _0x1.event.EventHandle<token_event_store.MaxiumMutateEvent>;
         extension: _0x1.option.Option<_0x1.any_.Any>;
     }
-    class UriMutationEvent {
-        static TYPE_QNAME: string;
+    namespace TokenEventStoreV1 {
+        const TYPE_QNAME = "0x3::token_event_store::TokenEventStoreV1";
+        function type(): TypeDescriptor<TokenEventStoreV1>;
+    }
+    interface UriMutationEvent {
         creator: Address;
         collection: string;
         token: string;
         old_uri: string;
         new_uri: string;
     }
+    namespace UriMutationEvent {
+        const TYPE_QNAME = "0x3::token_event_store::UriMutationEvent";
+        function type(): TypeDescriptor<UriMutationEvent>;
+    }
     interface UriMutationEventInstance extends TypedEventInstance<UriMutationEvent> {
         data_decoded: UriMutationEvent;
         type_arguments: [];