@sentio/sdk 2.57.11 → 2.57.12-rc.aaa

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

@@ -0,0 +1,1122 @@
+import { TypeDescriptor } from "@typemove/move";
+import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
+import { CallFilter, MoveFetchConfig } from "@sentio/sdk/move";
+import { AptosBindOptions, AptosBaseProcessor, TypedFunctionPayload, AptosContext } from "@sentio/sdk/aptos";
+import { MoveAddressType } from "@aptos-labs/ts-sdk";
+import * as _0x1 from "./0x1.js";
+export declare class token extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token;
+    onEntryBurn(func: (call: token.BurnPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryBurnByCreator(func: (call: token.BurnByCreatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryCreateCollectionScript(func: (call: token.CreateCollectionScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryCreateTokenScript(func: (call: token.CreateTokenScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryDirectTransferScript(func: (call: token.DirectTransferScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryInitializeTokenScript(func: (call: token.InitializeTokenScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryMintScript(func: (call: token.MintScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryMutateTokenProperties(func: (call: token.MutateTokenPropertiesPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryOptInDirectTransfer(func: (call: token.OptInDirectTransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEntryTransferWithOptIn(func: (call: token.TransferWithOptInPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventBurnToken(func: (event: token.BurnTokenInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventBurnTokenEvent(func: (event: token.BurnTokenEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventCollectionMutabilityConfig(func: (event: token.CollectionMutabilityConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventCreateCollection(func: (event: token.CreateCollectionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventCreateCollectionEvent(func: (event: token.CreateCollectionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventCreateTokenData(func: (event: token.CreateTokenDataInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventCreateTokenDataEvent(func: (event: token.CreateTokenDataEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventDeposit(func: (event: token.DepositInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventDepositEvent(func: (event: token.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventMintToken(func: (event: token.MintTokenInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventMintTokenEvent(func: (event: token.MintTokenEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventMutateTokenPropertyMap(func: (event: token.MutateTokenPropertyMapInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventMutateTokenPropertyMapEvent(func: (event: token.MutateTokenPropertyMapEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventRoyalty(func: (event: token.RoyaltyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventTokenDataId(func: (event: token.TokenDataIdInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventTokenId(func: (event: token.TokenIdInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventTokenMutabilityConfig(func: (event: token.TokenMutabilityConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventWithdraw(func: (event: token.WithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventWithdrawCapability(func: (event: token.WithdrawCapabilityInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+    onEventWithdrawEvent(func: (event: token.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token;
+}
+export declare namespace token {
+    interface BurnToken {
+        id: token.TokenId;
+        amount: bigint;
+    }
+    namespace BurnToken {
+        const TYPE_QNAME = "0x3::token::BurnToken";
+        function type(): TypeDescriptor<BurnToken>;
+    }
+    interface BurnTokenInstance extends TypedEventInstance<BurnToken> {
+        data_decoded: BurnToken;
+        type_arguments: [];
+    }
+    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: [];
+    }
+    interface CollectionData {
+        description: string;
+        name: string;
+        uri: string;
+        supply: bigint;
+        maximum: bigint;
+        mutability_config: token.CollectionMutabilityConfig;
+    }
+    namespace CollectionData {
+        const TYPE_QNAME = "0x3::token::CollectionData";
+        function type(): TypeDescriptor<CollectionData>;
+    }
+    interface CollectionMutabilityConfig {
+        description: Boolean;
+        uri: Boolean;
+        maximum: Boolean;
+    }
+    namespace CollectionMutabilityConfig {
+        const TYPE_QNAME = "0x3::token::CollectionMutabilityConfig";
+        function type(): TypeDescriptor<CollectionMutabilityConfig>;
+    }
+    interface CollectionMutabilityConfigInstance extends TypedEventInstance<CollectionMutabilityConfig> {
+        data_decoded: CollectionMutabilityConfig;
+        type_arguments: [];
+    }
+    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>;
+    }
+    namespace Collections {
+        const TYPE_QNAME = "0x3::token::Collections";
+        function type(): TypeDescriptor<Collections>;
+    }
+    interface CreateCollection {
+        creator: MoveAddressType;
+        collection_name: string;
+        uri: string;
+        description: string;
+        maximum: bigint;
+    }
+    namespace CreateCollection {
+        const TYPE_QNAME = "0x3::token::CreateCollection";
+        function type(): TypeDescriptor<CreateCollection>;
+    }
+    interface CreateCollectionInstance extends TypedEventInstance<CreateCollection> {
+        data_decoded: CreateCollection;
+        type_arguments: [];
+    }
+    interface CreateCollectionEvent {
+        creator: MoveAddressType;
+        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: [];
+    }
+    interface CreateTokenData {
+        id: token.TokenDataId;
+        description: string;
+        maximum: bigint;
+        uri: string;
+        royalty_payee_address: MoveAddressType;
+        royalty_points_denominator: bigint;
+        royalty_points_numerator: bigint;
+        name: string;
+        mutability_config: token.TokenMutabilityConfig;
+        property_keys: string[];
+        property_values: string[];
+        property_types: string[];
+    }
+    namespace CreateTokenData {
+        const TYPE_QNAME = "0x3::token::CreateTokenData";
+        function type(): TypeDescriptor<CreateTokenData>;
+    }
+    interface CreateTokenDataInstance extends TypedEventInstance<CreateTokenData> {
+        data_decoded: CreateTokenData;
+        type_arguments: [];
+    }
+    interface CreateTokenDataEvent {
+        id: token.TokenDataId;
+        description: string;
+        maximum: bigint;
+        uri: string;
+        royalty_payee_address: MoveAddressType;
+        royalty_points_denominator: bigint;
+        royalty_points_numerator: bigint;
+        name: string;
+        mutability_config: token.TokenMutabilityConfig;
+        property_keys: string[];
+        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: [];
+    }
+    interface Deposit {
+        id: token.TokenId;
+        amount: bigint;
+    }
+    namespace Deposit {
+        const TYPE_QNAME = "0x3::token::Deposit";
+        function type(): TypeDescriptor<Deposit>;
+    }
+    interface DepositInstance extends TypedEventInstance<Deposit> {
+        data_decoded: Deposit;
+        type_arguments: [];
+    }
+    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: [];
+    }
+    interface MintToken {
+        id: token.TokenDataId;
+        amount: bigint;
+    }
+    namespace MintToken {
+        const TYPE_QNAME = "0x3::token::MintToken";
+        function type(): TypeDescriptor<MintToken>;
+    }
+    interface MintTokenInstance extends TypedEventInstance<MintToken> {
+        data_decoded: MintToken;
+        type_arguments: [];
+    }
+    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: [];
+    }
+    interface MutateTokenPropertyMap {
+        old_id: token.TokenId;
+        new_id: token.TokenId;
+        keys: string[];
+        values: string[];
+        types: string[];
+    }
+    namespace MutateTokenPropertyMap {
+        const TYPE_QNAME = "0x3::token::MutateTokenPropertyMap";
+        function type(): TypeDescriptor<MutateTokenPropertyMap>;
+    }
+    interface MutateTokenPropertyMapInstance extends TypedEventInstance<MutateTokenPropertyMap> {
+        data_decoded: MutateTokenPropertyMap;
+        type_arguments: [];
+    }
+    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: [];
+    }
+    interface Royalty {
+        royalty_points_numerator: bigint;
+        royalty_points_denominator: bigint;
+        payee_address: MoveAddressType;
+    }
+    namespace Royalty {
+        const TYPE_QNAME = "0x3::token::Royalty";
+        function type(): TypeDescriptor<Royalty>;
+    }
+    interface RoyaltyInstance extends TypedEventInstance<Royalty> {
+        data_decoded: Royalty;
+        type_arguments: [];
+    }
+    interface Token {
+        id: token.TokenId;
+        amount: bigint;
+        token_properties: property_map.PropertyMap;
+    }
+    namespace Token {
+        const TYPE_QNAME = "0x3::token::Token";
+        function type(): TypeDescriptor<Token>;
+    }
+    interface TokenData {
+        maximum: bigint;
+        largest_property_version: bigint;
+        supply: bigint;
+        uri: string;
+        royalty: token.Royalty;
+        name: string;
+        description: string;
+        default_properties: property_map.PropertyMap;
+        mutability_config: token.TokenMutabilityConfig;
+    }
+    namespace TokenData {
+        const TYPE_QNAME = "0x3::token::TokenData";
+        function type(): TypeDescriptor<TokenData>;
+    }
+    interface TokenDataId {
+        creator: MoveAddressType;
+        collection: string;
+        name: string;
+    }
+    namespace TokenDataId {
+        const TYPE_QNAME = "0x3::token::TokenDataId";
+        function type(): TypeDescriptor<TokenDataId>;
+    }
+    interface TokenDataIdInstance extends TypedEventInstance<TokenDataId> {
+        data_decoded: TokenDataId;
+        type_arguments: [];
+    }
+    interface TokenId {
+        token_data_id: token.TokenDataId;
+        property_version: bigint;
+    }
+    namespace TokenId {
+        const TYPE_QNAME = "0x3::token::TokenId";
+        function type(): TypeDescriptor<TokenId>;
+    }
+    interface TokenIdInstance extends TypedEventInstance<TokenId> {
+        data_decoded: TokenId;
+        type_arguments: [];
+    }
+    interface TokenMutabilityConfig {
+        maximum: Boolean;
+        uri: Boolean;
+        royalty: Boolean;
+        description: Boolean;
+        properties: Boolean;
+    }
+    namespace TokenMutabilityConfig {
+        const TYPE_QNAME = "0x3::token::TokenMutabilityConfig";
+        function type(): TypeDescriptor<TokenMutabilityConfig>;
+    }
+    interface TokenMutabilityConfigInstance extends TypedEventInstance<TokenMutabilityConfig> {
+        data_decoded: TokenMutabilityConfig;
+        type_arguments: [];
+    }
+    interface TokenStore {
+        tokens: _0x1.table.Table<token.TokenId, token.Token>;
+        direct_transfer: Boolean;
+        deposit_events: _0x1.event.EventHandle<token.DepositEvent>;
+        withdraw_events: _0x1.event.EventHandle<token.WithdrawEvent>;
+        burn_events: _0x1.event.EventHandle<token.BurnTokenEvent>;
+        mutate_token_property_events: _0x1.event.EventHandle<token.MutateTokenPropertyMapEvent>;
+    }
+    namespace TokenStore {
+        const TYPE_QNAME = "0x3::token::TokenStore";
+        function type(): TypeDescriptor<TokenStore>;
+    }
+    interface Withdraw {
+        id: token.TokenId;
+        amount: bigint;
+    }
+    namespace Withdraw {
+        const TYPE_QNAME = "0x3::token::Withdraw";
+        function type(): TypeDescriptor<Withdraw>;
+    }
+    interface WithdrawInstance extends TypedEventInstance<Withdraw> {
+        data_decoded: Withdraw;
+        type_arguments: [];
+    }
+    interface WithdrawCapability {
+        token_owner: MoveAddressType;
+        token_id: token.TokenId;
+        amount: bigint;
+        expiration_sec: bigint;
+    }
+    namespace WithdrawCapability {
+        const TYPE_QNAME = "0x3::token::WithdrawCapability";
+        function type(): TypeDescriptor<WithdrawCapability>;
+    }
+    interface WithdrawCapabilityInstance extends TypedEventInstance<WithdrawCapability> {
+        data_decoded: WithdrawCapability;
+        type_arguments: [];
+    }
+    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: [];
+    }
+    interface BurnPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [MoveAddressType, string, string, bigint, bigint];
+        type_arguments: [];
+    }
+    interface BurnByCreatorPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [MoveAddressType, string, string, bigint, bigint];
+        type_arguments: [];
+    }
+    interface CreateCollectionScriptPayload extends TypedFunctionPayload<[string, string, string, bigint, Boolean[]]> {
+        arguments_decoded: [string, string, string, bigint, Boolean[]];
+        type_arguments: [];
+    }
+    interface CreateTokenScriptPayload extends TypedFunctionPayload<[
+        string,
+        string,
+        string,
+        bigint,
+        bigint,
+        string,
+        MoveAddressType,
+        bigint,
+        bigint,
+        Boolean[],
+        string[],
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            string,
+            string,
+            string,
+            bigint,
+            bigint,
+            string,
+            MoveAddressType,
+            bigint,
+            bigint,
+            Boolean[],
+            string[],
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface DirectTransferScriptPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            MoveAddressType,
+            string,
+            string,
+            bigint,
+            bigint
+        ];
+        type_arguments: [];
+    }
+    interface InitializeTokenScriptPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface MintScriptPayload extends TypedFunctionPayload<[MoveAddressType, string, string, bigint]> {
+        arguments_decoded: [MoveAddressType, string, string, bigint];
+        type_arguments: [];
+    }
+    interface MutateTokenPropertiesPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        bigint,
+        string[],
+        string[],
+        string[]
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            MoveAddressType,
+            string,
+            string,
+            bigint,
+            bigint,
+            string[],
+            string[],
+            string[]
+        ];
+        type_arguments: [];
+    }
+    interface OptInDirectTransferPayload extends TypedFunctionPayload<[Boolean]> {
+        arguments_decoded: [Boolean];
+        type_arguments: [];
+    }
+    interface TransferWithOptInPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        MoveAddressType,
+        bigint
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            string,
+            string,
+            bigint,
+            MoveAddressType,
+            bigint
+        ];
+        type_arguments: [];
+    }
+}
+export declare class property_map extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): property_map;
+    onEventPropertyMap(func: (event: property_map.PropertyMapInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): property_map;
+    onEventPropertyValue(func: (event: property_map.PropertyValueInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): property_map;
+}
+export declare namespace property_map {
+    interface PropertyMap {
+        map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
+    }
+    namespace PropertyMap {
+        const TYPE_QNAME = "0x3::property_map::PropertyMap";
+        function type(): TypeDescriptor<PropertyMap>;
+    }
+    interface PropertyMapInstance extends TypedEventInstance<PropertyMap> {
+        data_decoded: PropertyMap;
+        type_arguments: [];
+    }
+    interface PropertyValue {
+        value: string;
+        type: string;
+    }
+    namespace PropertyValue {
+        const TYPE_QNAME = "0x3::property_map::PropertyValue";
+        function type(): TypeDescriptor<PropertyValue>;
+    }
+    interface PropertyValueInstance extends TypedEventInstance<PropertyValue> {
+        data_decoded: PropertyValue;
+        type_arguments: [];
+    }
+}
+export declare class token_coin_swap extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token_coin_swap;
+    onEntryListTokenForSwap(func: (call: token_coin_swap.ListTokenForSwapPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token_coin_swap;
+    onEventTokenCoinSwap(func: (event: token_coin_swap.TokenCoinSwapInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_coin_swap;
+    onEventTokenListingEvent(func: (event: token_coin_swap.TokenListingEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_coin_swap;
+    onEventTokenSwapEvent(func: (event: token_coin_swap.TokenSwapEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_coin_swap;
+}
+export declare namespace token_coin_swap {
+    interface TokenCoinSwap<T0> {
+        token_amount: bigint;
+        min_price_per_token: bigint;
+    }
+    namespace TokenCoinSwap {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenCoinSwap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TokenCoinSwap<T0>>;
+    }
+    interface TokenCoinSwapInstance extends TypedEventInstance<TokenCoinSwap<any>> {
+        data_decoded: TokenCoinSwap<any>;
+        type_arguments: [string];
+    }
+    interface TokenEscrow {
+        token: token.Token;
+        locked_until_secs: bigint;
+    }
+    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: [];
+    }
+    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>;
+    }
+    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>;
+    }
+    namespace TokenStoreEscrow {
+        const TYPE_QNAME = "0x3::token_coin_swap::TokenStoreEscrow";
+        function type(): TypeDescriptor<TokenStoreEscrow>;
+    }
+    interface TokenSwapEvent {
+        token_id: token.TokenId;
+        token_buyer: MoveAddressType;
+        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: [];
+    }
+    interface ListTokenForSwapPayload<T0 = any> extends TypedFunctionPayload<[
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        bigint,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            string,
+            string,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ];
+        type_arguments: [string];
+    }
+}
+export declare class token_transfers extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token_transfers;
+    onEntryCancelOfferScript(func: (call: token_transfers.CancelOfferScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEntryClaimScript(func: (call: token_transfers.ClaimScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEntryOfferScript(func: (call: token_transfers.OfferScriptPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenCancelOffer(func: (event: token_transfers.TokenCancelOfferInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenCancelOfferEvent(func: (event: token_transfers.TokenCancelOfferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenClaim(func: (event: token_transfers.TokenClaimInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenClaimEvent(func: (event: token_transfers.TokenClaimEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenOffer(func: (event: token_transfers.TokenOfferInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenOfferEvent(func: (event: token_transfers.TokenOfferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+    onEventTokenOfferId(func: (event: token_transfers.TokenOfferIdInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_transfers;
+}
+export declare namespace token_transfers {
+    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>;
+    }
+    namespace PendingClaims {
+        const TYPE_QNAME = "0x3::token_transfers::PendingClaims";
+        function type(): TypeDescriptor<PendingClaims>;
+    }
+    interface TokenCancelOffer {
+        to_address: MoveAddressType;
+        token_id: token.TokenId;
+        amount: bigint;
+    }
+    namespace TokenCancelOffer {
+        const TYPE_QNAME = "0x3::token_transfers::TokenCancelOffer";
+        function type(): TypeDescriptor<TokenCancelOffer>;
+    }
+    interface TokenCancelOfferInstance extends TypedEventInstance<TokenCancelOffer> {
+        data_decoded: TokenCancelOffer;
+        type_arguments: [];
+    }
+    interface TokenCancelOfferEvent {
+        to_address: MoveAddressType;
+        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: [];
+    }
+    interface TokenClaim {
+        to_address: MoveAddressType;
+        token_id: token.TokenId;
+        amount: bigint;
+    }
+    namespace TokenClaim {
+        const TYPE_QNAME = "0x3::token_transfers::TokenClaim";
+        function type(): TypeDescriptor<TokenClaim>;
+    }
+    interface TokenClaimInstance extends TypedEventInstance<TokenClaim> {
+        data_decoded: TokenClaim;
+        type_arguments: [];
+    }
+    interface TokenClaimEvent {
+        to_address: MoveAddressType;
+        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: [];
+    }
+    interface TokenOffer {
+        to_address: MoveAddressType;
+        token_id: token.TokenId;
+        amount: bigint;
+    }
+    namespace TokenOffer {
+        const TYPE_QNAME = "0x3::token_transfers::TokenOffer";
+        function type(): TypeDescriptor<TokenOffer>;
+    }
+    interface TokenOfferInstance extends TypedEventInstance<TokenOffer> {
+        data_decoded: TokenOffer;
+        type_arguments: [];
+    }
+    interface TokenOfferEvent {
+        to_address: MoveAddressType;
+        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: [];
+    }
+    interface TokenOfferId {
+        to_addr: MoveAddressType;
+        token_id: token.TokenId;
+    }
+    namespace TokenOfferId {
+        const TYPE_QNAME = "0x3::token_transfers::TokenOfferId";
+        function type(): TypeDescriptor<TokenOfferId>;
+    }
+    interface TokenOfferIdInstance extends TypedEventInstance<TokenOfferId> {
+        data_decoded: TokenOfferId;
+        type_arguments: [];
+    }
+    interface CancelOfferScriptPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        MoveAddressType,
+        MoveAddressType,
+        string,
+        string,
+        bigint
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            MoveAddressType,
+            MoveAddressType,
+            string,
+            string,
+            bigint
+        ];
+        type_arguments: [];
+    }
+    interface ClaimScriptPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        MoveAddressType,
+        MoveAddressType,
+        string,
+        string,
+        bigint
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            MoveAddressType,
+            MoveAddressType,
+            string,
+            string,
+            bigint
+        ];
+        type_arguments: [];
+    }
+    interface OfferScriptPayload extends TypedFunctionPayload<[
+        MoveAddressType,
+        MoveAddressType,
+        MoveAddressType,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            MoveAddressType,
+            MoveAddressType,
+            MoveAddressType,
+            string,
+            string,
+            bigint,
+            bigint
+        ];
+        type_arguments: [];
+    }
+}
+export declare class token_event_store extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): token_event_store;
+    onEventCollectionDescriptionMutate(func: (event: token_event_store.CollectionDescriptionMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventCollectionDescriptionMutateEvent(func: (event: token_event_store.CollectionDescriptionMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventCollectionMaxiumMutate(func: (event: token_event_store.CollectionMaxiumMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventCollectionMaxiumMutateEvent(func: (event: token_event_store.CollectionMaxiumMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventCollectionUriMutate(func: (event: token_event_store.CollectionUriMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventCollectionUriMutateEvent(func: (event: token_event_store.CollectionUriMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventDefaultPropertyMutate(func: (event: token_event_store.DefaultPropertyMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventDefaultPropertyMutateEvent(func: (event: token_event_store.DefaultPropertyMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventDescriptionMutate(func: (event: token_event_store.DescriptionMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventDescriptionMutateEvent(func: (event: token_event_store.DescriptionMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventMaximumMutate(func: (event: token_event_store.MaximumMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventMaxiumMutateEvent(func: (event: token_event_store.MaxiumMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventOptInTransfer(func: (event: token_event_store.OptInTransferInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventOptInTransferEvent(func: (event: token_event_store.OptInTransferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventRoyaltyMutate(func: (event: token_event_store.RoyaltyMutateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventRoyaltyMutateEvent(func: (event: token_event_store.RoyaltyMutateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventUriMutation(func: (event: token_event_store.UriMutationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+    onEventUriMutationEvent(func: (event: token_event_store.UriMutationEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): token_event_store;
+}
+export declare namespace token_event_store {
+    interface CollectionDescriptionMutate {
+        creator_addr: MoveAddressType;
+        collection_name: string;
+        old_description: string;
+        new_description: string;
+    }
+    namespace CollectionDescriptionMutate {
+        const TYPE_QNAME = "0x3::token_event_store::CollectionDescriptionMutate";
+        function type(): TypeDescriptor<CollectionDescriptionMutate>;
+    }
+    interface CollectionDescriptionMutateInstance extends TypedEventInstance<CollectionDescriptionMutate> {
+        data_decoded: CollectionDescriptionMutate;
+        type_arguments: [];
+    }
+    interface CollectionDescriptionMutateEvent {
+        creator_addr: MoveAddressType;
+        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: [];
+    }
+    interface CollectionMaxiumMutate {
+        creator_addr: MoveAddressType;
+        collection_name: string;
+        old_maximum: bigint;
+        new_maximum: bigint;
+    }
+    namespace CollectionMaxiumMutate {
+        const TYPE_QNAME = "0x3::token_event_store::CollectionMaxiumMutate";
+        function type(): TypeDescriptor<CollectionMaxiumMutate>;
+    }
+    interface CollectionMaxiumMutateInstance extends TypedEventInstance<CollectionMaxiumMutate> {
+        data_decoded: CollectionMaxiumMutate;
+        type_arguments: [];
+    }
+    interface CollectionMaxiumMutateEvent {
+        creator_addr: MoveAddressType;
+        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: [];
+    }
+    interface CollectionUriMutate {
+        creator_addr: MoveAddressType;
+        collection_name: string;
+        old_uri: string;
+        new_uri: string;
+    }
+    namespace CollectionUriMutate {
+        const TYPE_QNAME = "0x3::token_event_store::CollectionUriMutate";
+        function type(): TypeDescriptor<CollectionUriMutate>;
+    }
+    interface CollectionUriMutateInstance extends TypedEventInstance<CollectionUriMutate> {
+        data_decoded: CollectionUriMutate;
+        type_arguments: [];
+    }
+    interface CollectionUriMutateEvent {
+        creator_addr: MoveAddressType;
+        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: [];
+    }
+    interface DefaultPropertyMutate {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        keys: string[];
+        old_values: _0x1.option.Option<property_map.PropertyValue>[];
+        new_values: property_map.PropertyValue[];
+    }
+    namespace DefaultPropertyMutate {
+        const TYPE_QNAME = "0x3::token_event_store::DefaultPropertyMutate";
+        function type(): TypeDescriptor<DefaultPropertyMutate>;
+    }
+    interface DefaultPropertyMutateInstance extends TypedEventInstance<DefaultPropertyMutate> {
+        data_decoded: DefaultPropertyMutate;
+        type_arguments: [];
+    }
+    interface DefaultPropertyMutateEvent {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        keys: string[];
+        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: [];
+    }
+    interface DescriptionMutate {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        old_description: string;
+        new_description: string;
+    }
+    namespace DescriptionMutate {
+        const TYPE_QNAME = "0x3::token_event_store::DescriptionMutate";
+        function type(): TypeDescriptor<DescriptionMutate>;
+    }
+    interface DescriptionMutateInstance extends TypedEventInstance<DescriptionMutate> {
+        data_decoded: DescriptionMutate;
+        type_arguments: [];
+    }
+    interface DescriptionMutateEvent {
+        creator: MoveAddressType;
+        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: [];
+    }
+    interface MaximumMutate {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        old_maximum: bigint;
+        new_maximum: bigint;
+    }
+    namespace MaximumMutate {
+        const TYPE_QNAME = "0x3::token_event_store::MaximumMutate";
+        function type(): TypeDescriptor<MaximumMutate>;
+    }
+    interface MaximumMutateInstance extends TypedEventInstance<MaximumMutate> {
+        data_decoded: MaximumMutate;
+        type_arguments: [];
+    }
+    interface MaxiumMutateEvent {
+        creator: MoveAddressType;
+        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: [];
+    }
+    interface OptInTransfer {
+        account_address: MoveAddressType;
+        opt_in: Boolean;
+    }
+    namespace OptInTransfer {
+        const TYPE_QNAME = "0x3::token_event_store::OptInTransfer";
+        function type(): TypeDescriptor<OptInTransfer>;
+    }
+    interface OptInTransferInstance extends TypedEventInstance<OptInTransfer> {
+        data_decoded: OptInTransfer;
+        type_arguments: [];
+    }
+    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: [];
+    }
+    interface RoyaltyMutate {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        old_royalty_numerator: bigint;
+        old_royalty_denominator: bigint;
+        old_royalty_payee_addr: MoveAddressType;
+        new_royalty_numerator: bigint;
+        new_royalty_denominator: bigint;
+        new_royalty_payee_addr: MoveAddressType;
+    }
+    namespace RoyaltyMutate {
+        const TYPE_QNAME = "0x3::token_event_store::RoyaltyMutate";
+        function type(): TypeDescriptor<RoyaltyMutate>;
+    }
+    interface RoyaltyMutateInstance extends TypedEventInstance<RoyaltyMutate> {
+        data_decoded: RoyaltyMutate;
+        type_arguments: [];
+    }
+    interface RoyaltyMutateEvent {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        old_royalty_numerator: bigint;
+        old_royalty_denominator: bigint;
+        old_royalty_payee_addr: MoveAddressType;
+        new_royalty_numerator: bigint;
+        new_royalty_denominator: bigint;
+        new_royalty_payee_addr: MoveAddressType;
+    }
+    namespace RoyaltyMutateEvent {
+        const TYPE_QNAME = "0x3::token_event_store::RoyaltyMutateEvent";
+        function type(): TypeDescriptor<RoyaltyMutateEvent>;
+    }
+    interface RoyaltyMutateEventInstance extends TypedEventInstance<RoyaltyMutateEvent> {
+        data_decoded: RoyaltyMutateEvent;
+        type_arguments: [];
+    }
+    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>;
+        opt_in_events: _0x1.event.EventHandle<token_event_store.OptInTransferEvent>;
+        uri_mutate_events: _0x1.event.EventHandle<token_event_store.UriMutationEvent>;
+        default_property_mutate_events: _0x1.event.EventHandle<token_event_store.DefaultPropertyMutateEvent>;
+        description_mutate_events: _0x1.event.EventHandle<token_event_store.DescriptionMutateEvent>;
+        royalty_mutate_events: _0x1.event.EventHandle<token_event_store.RoyaltyMutateEvent>;
+        maximum_mutate_events: _0x1.event.EventHandle<token_event_store.MaxiumMutateEvent>;
+        extension: _0x1.option.Option<_0x1.any_.Any>;
+    }
+    namespace TokenEventStoreV1 {
+        const TYPE_QNAME = "0x3::token_event_store::TokenEventStoreV1";
+        function type(): TypeDescriptor<TokenEventStoreV1>;
+    }
+    interface UriMutation {
+        creator: MoveAddressType;
+        collection: string;
+        token: string;
+        old_uri: string;
+        new_uri: string;
+    }
+    namespace UriMutation {
+        const TYPE_QNAME = "0x3::token_event_store::UriMutation";
+        function type(): TypeDescriptor<UriMutation>;
+    }
+    interface UriMutationInstance extends TypedEventInstance<UriMutation> {
+        data_decoded: UriMutation;
+        type_arguments: [];
+    }
+    interface UriMutationEvent {
+        creator: MoveAddressType;
+        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: [];
+    }
+}
+export declare function loadAllTypes(coder: MoveCoder): void;
+//# sourceMappingURL=0x3.d.ts.map