import { TypeDescriptor } from "@typemove/move";
import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId } from "@aptos-labs/ts-sdk";
import * as _0x1 from "./0x1.js";
export declare namespace token {
    interface Deposit {
        id: token.TokenId;
        amount: bigint;
    }
    namespace Deposit {
        const TYPE_QNAME = "0x3::token::Deposit";
        function type(): TypeDescriptor<Deposit>;
    }
    type DepositInstance = 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>;
    }
    type DepositEventInstance = TypedEventInstance<DepositEvent> & {
        data_decoded: DepositEvent;
        type_arguments: [];
    };
    interface Withdraw {
        id: token.TokenId;
        amount: bigint;
    }
    namespace Withdraw {
        const TYPE_QNAME = "0x3::token::Withdraw";
        function type(): TypeDescriptor<Withdraw>;
    }
    type WithdrawInstance = TypedEventInstance<Withdraw> & {
        data_decoded: Withdraw;
        type_arguments: [];
    };
    interface WithdrawEvent {
        id: token.TokenId;
        amount: bigint;
    }
    namespace WithdrawEvent {
        const TYPE_QNAME = "0x3::token::WithdrawEvent";
        function type(): TypeDescriptor<WithdrawEvent>;
    }
    type WithdrawEventInstance = TypedEventInstance<WithdrawEvent> & {
        data_decoded: WithdrawEvent;
        type_arguments: [];
    };
    interface Burn {
        account: MoveAddressType;
        id: token.TokenId;
        amount: bigint;
    }
    namespace Burn {
        const TYPE_QNAME = "0x3::token::Burn";
        function type(): TypeDescriptor<Burn>;
    }
    type BurnInstance = TypedEventInstance<Burn> & {
        data_decoded: Burn;
        type_arguments: [];
    };
    interface BurnToken {
        id: token.TokenId;
        amount: bigint;
    }
    namespace BurnToken {
        const TYPE_QNAME = "0x3::token::BurnToken";
        function type(): TypeDescriptor<BurnToken>;
    }
    type BurnTokenInstance = 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>;
    }
    type BurnTokenEventInstance = 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 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>;
    }
    type CreateCollectionInstance = 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>;
    }
    type CreateCollectionEventInstance = 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>;
    }
    type CreateTokenDataInstance = 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>;
    }
    type CreateTokenDataEventInstance = TypedEventInstance<CreateTokenDataEvent> & {
        data_decoded: CreateTokenDataEvent;
        type_arguments: [];
    };
    interface Mint {
        creator: MoveAddressType;
        id: token.TokenDataId;
        amount: bigint;
    }
    namespace Mint {
        const TYPE_QNAME = "0x3::token::Mint";
        function type(): TypeDescriptor<Mint>;
    }
    type MintInstance = TypedEventInstance<Mint> & {
        data_decoded: Mint;
        type_arguments: [];
    };
    interface MintToken {
        id: token.TokenDataId;
        amount: bigint;
    }
    namespace MintToken {
        const TYPE_QNAME = "0x3::token::MintToken";
        function type(): TypeDescriptor<MintToken>;
    }
    type MintTokenInstance = 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>;
    }
    type MintTokenEventInstance = TypedEventInstance<MintTokenEvent> & {
        data_decoded: MintTokenEvent;
        type_arguments: [];
    };
    interface MutatePropertyMap {
        account: MoveAddressType;
        old_id: token.TokenId;
        new_id: token.TokenId;
        keys: string[];
        values: string[];
        types: string[];
    }
    namespace MutatePropertyMap {
        const TYPE_QNAME = "0x3::token::MutatePropertyMap";
        function type(): TypeDescriptor<MutatePropertyMap>;
    }
    type MutatePropertyMapInstance = TypedEventInstance<MutatePropertyMap> & {
        data_decoded: MutatePropertyMap;
        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>;
    }
    type MutateTokenPropertyMapInstance = 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>;
    }
    type MutateTokenPropertyMapEventInstance = 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 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 TokenDataCreation {
        creator: MoveAddressType;
        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 TokenDataCreation {
        const TYPE_QNAME = "0x3::token::TokenDataCreation";
        function type(): TypeDescriptor<TokenDataCreation>;
    }
    type TokenDataCreationInstance = TypedEventInstance<TokenDataCreation> & {
        data_decoded: TokenDataCreation;
        type_arguments: [];
    };
    interface TokenDataId {
        creator: MoveAddressType;
        collection: string;
        name: string;
    }
    namespace TokenDataId {
        const TYPE_QNAME = "0x3::token::TokenDataId";
        function type(): TypeDescriptor<TokenDataId>;
    }
    interface TokenDeposit {
        account: MoveAddressType;
        id: token.TokenId;
        amount: bigint;
    }
    namespace TokenDeposit {
        const TYPE_QNAME = "0x3::token::TokenDeposit";
        function type(): TypeDescriptor<TokenDeposit>;
    }
    type TokenDepositInstance = TypedEventInstance<TokenDeposit> & {
        data_decoded: TokenDeposit;
        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 TokenMutabilityConfig {
        maximum: boolean;
        uri: boolean;
        royalty: boolean;
        description: boolean;
        properties: boolean;
    }
    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>;
        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 TokenWithdraw {
        account: MoveAddressType;
        id: token.TokenId;
        amount: bigint;
    }
    namespace TokenWithdraw {
        const TYPE_QNAME = "0x3::token::TokenWithdraw";
        function type(): TypeDescriptor<TokenWithdraw>;
    }
    type TokenWithdrawInstance = TypedEventInstance<TokenWithdraw> & {
        data_decoded: TokenWithdraw;
        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>;
    }
    type WithdrawCapabilityInstance = TypedEventInstance<WithdrawCapability> & {
        data_decoded: WithdrawCapability;
        type_arguments: [];
    };
    namespace entry {
        function burn(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [MoveAddressType, string, string, bigint, bigint];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function burnByCreator(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [MoveAddressType, string, string, bigint, bigint];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function createCollectionScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [string, string, string, bigint, boolean[]];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function createTokenScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                string,
                string,
                string,
                bigint,
                bigint,
                string,
                MoveAddressType,
                bigint,
                bigint,
                boolean[],
                string[],
                string[],
                string[]
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function directTransferScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                MoveAddressType,
                MoveAddressType,
                string,
                string,
                bigint,
                bigint
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function initializeTokenScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function mintScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [MoveAddressType, string, string, bigint];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function mutateTokenProperties(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                MoveAddressType,
                MoveAddressType,
                string,
                string,
                bigint,
                bigint,
                string[],
                string[],
                string[]
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function optInDirectTransfer(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [boolean];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function transferWithOptIn(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                MoveAddressType,
                string,
                string,
                bigint,
                MoveAddressType,
                bigint
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
    }
    namespace view {
        function getCollectionMutabilityConfig(client: Aptos, request: {
            functionArguments: [MoveAddressType, string];
        }, version?: bigint): Promise<[token.CollectionMutabilityConfig]>;
    }
}
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 PropertyValue {
        value: string;
        type: string;
    }
    namespace PropertyValue {
        const TYPE_QNAME = "0x3::property_map::PropertyValue";
        function type(): TypeDescriptor<PropertyValue>;
    }
    namespace entry { }
    namespace view { }
}
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>>;
    }
    type TokenCoinSwapInstance = 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>;
    }
    type TokenListingEventInstance = 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>;
    }
    type TokenSwapEventInstance = TypedEventInstance<TokenSwapEvent> & {
        data_decoded: TokenSwapEvent;
        type_arguments: [];
    };
    namespace entry {
        function listTokenForSwap<T0 = any>(client: Aptos, account: AptosAccount, request: {
            typeArguments: [MoveStructId];
            functionArguments: [
                MoveAddressType,
                string,
                string,
                bigint,
                bigint,
                bigint,
                bigint
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
    }
    namespace view { }
}
export declare namespace token_transfers {
    interface CancelOffer {
        account: MoveAddressType;
        to_address: MoveAddressType;
        token_id: token.TokenId;
        amount: bigint;
    }
    namespace CancelOffer {
        const TYPE_QNAME = "0x3::token_transfers::CancelOffer";
        function type(): TypeDescriptor<CancelOffer>;
    }
    type CancelOfferInstance = TypedEventInstance<CancelOffer> & {
        data_decoded: CancelOffer;
        type_arguments: [];
    };
    interface Claim {
        account: MoveAddressType;
        to_address: MoveAddressType;
        token_id: token.TokenId;
        amount: bigint;
    }
    namespace Claim {
        const TYPE_QNAME = "0x3::token_transfers::Claim";
        function type(): TypeDescriptor<Claim>;
    }
    type ClaimInstance = TypedEventInstance<Claim> & {
        data_decoded: Claim;
        type_arguments: [];
    };
    interface Offer {
        account: MoveAddressType;
        to_address: MoveAddressType;
        token_id: token.TokenId;
        amount: bigint;
    }
    namespace Offer {
        const TYPE_QNAME = "0x3::token_transfers::Offer";
        function type(): TypeDescriptor<Offer>;
    }
    type OfferInstance = TypedEventInstance<Offer> & {
        data_decoded: Offer;
        type_arguments: [];
    };
    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>;
    }
    type TokenCancelOfferInstance = 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>;
    }
    type TokenCancelOfferEventInstance = 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>;
    }
    type TokenClaimInstance = 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>;
    }
    type TokenClaimEventInstance = 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>;
    }
    type TokenOfferInstance = 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>;
    }
    type TokenOfferEventInstance = 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>;
    }
    type TokenOfferIdInstance = TypedEventInstance<TokenOfferId> & {
        data_decoded: TokenOfferId;
        type_arguments: [];
    };
    namespace entry {
        function cancelOfferScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                MoveAddressType,
                MoveAddressType,
                MoveAddressType,
                string,
                string,
                bigint
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function claimScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                MoveAddressType,
                MoveAddressType,
                MoveAddressType,
                string,
                string,
                bigint
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
        function offerScript(client: Aptos, account: AptosAccount, request: {
            typeArguments: [];
            functionArguments: [
                MoveAddressType,
                MoveAddressType,
                MoveAddressType,
                string,
                string,
                bigint,
                bigint
            ];
        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
    }
    namespace view { }
}
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>;
    }
    type CollectionDescriptionMutateInstance = 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>;
    }
    type CollectionDescriptionMutateEventInstance = TypedEventInstance<CollectionDescriptionMutateEvent> & {
        data_decoded: CollectionDescriptionMutateEvent;
        type_arguments: [];
    };
    interface CollectionMaximumMutate {
        creator_addr: MoveAddressType;
        collection_name: string;
        old_maximum: bigint;
        new_maximum: bigint;
    }
    namespace CollectionMaximumMutate {
        const TYPE_QNAME = "0x3::token_event_store::CollectionMaximumMutate";
        function type(): TypeDescriptor<CollectionMaximumMutate>;
    }
    type CollectionMaximumMutateInstance = TypedEventInstance<CollectionMaximumMutate> & {
        data_decoded: CollectionMaximumMutate;
        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>;
    }
    type CollectionMaxiumMutateInstance = 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>;
    }
    type CollectionMaxiumMutateEventInstance = 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>;
    }
    type CollectionUriMutateInstance = 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>;
    }
    type CollectionUriMutateEventInstance = 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>;
    }
    type DefaultPropertyMutateInstance = 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>;
    }
    type DefaultPropertyMutateEventInstance = 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>;
    }
    type DescriptionMutateInstance = 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>;
    }
    type DescriptionMutateEventInstance = 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>;
    }
    type MaximumMutateInstance = 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>;
    }
    type MaxiumMutateEventInstance = 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>;
    }
    type OptInTransferInstance = 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>;
    }
    type OptInTransferEventInstance = 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>;
    }
    type RoyaltyMutateInstance = 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>;
    }
    type RoyaltyMutateEventInstance = 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>;
    }
    type UriMutationInstance = 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>;
    }
    type UriMutationEventInstance = TypedEventInstance<UriMutationEvent> & {
        data_decoded: UriMutationEvent;
        type_arguments: [];
    };
    namespace entry { }
    namespace view { }
}
export declare function loadAllTypes(coder: MoveCoder): void;
//# sourceMappingURL=0x3.d.ts.map