/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

/* Generated types for 0x3, original address 0x3 */

import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move";
import { HandlerOptions } from "@sentio/sdk";
import {
  AptosBindOptions,
  AptosBaseProcessor,
  AptosNetwork,
  TypedFunctionPayload,
  AptosContext,
} from "@sentio/sdk/aptos";

import { TypeDescriptor, ANY_TYPE } from "@typemove/move";
import { MoveCoder, TypedEventInstance } from "@typemove/aptos";

import { defaultMoveCoder, defaultMoveCoderForClient } from "@sentio/sdk/aptos";
import {
  Aptos,
  Account as AptosAccount,
  MoveAddressType,
  PendingTransactionResponse,
  InputGenerateTransactionOptions,
  MoveStructId,
  InputViewFunctionData,
  InputViewFunctionJsonData,
} from "@aptos-labs/ts-sdk";

import * as _0x1 from "./0x1.js";

export class token extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("token", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x3",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): token {
    return new token({ ...token.DEFAULT_OPTIONS, ...options });
  }

  onEntryBurn(
    func: (call: token.BurnPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.BurnPayload>,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::burn",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBurnByCreator(
    func: (call: token.BurnByCreatorPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.BurnByCreatorPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::burn_by_creator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateCollectionScript(
    func: (
      call: token.CreateCollectionScriptPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.CreateCollectionScriptPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::create_collection_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateTokenScript(
    func: (call: token.CreateTokenScriptPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.CreateTokenScriptPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::create_token_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDirectTransferScript(
    func: (call: token.DirectTransferScriptPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.DirectTransferScriptPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::direct_transfer_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryInitializeTokenScript(
    func: (call: token.InitializeTokenScriptPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.InitializeTokenScriptPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::initialize_token_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryMintScript(
    func: (call: token.MintScriptPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.MintScriptPayload>,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::mint_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryMutateTokenProperties(
    func: (call: token.MutateTokenPropertiesPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.MutateTokenPropertiesPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::mutate_token_properties",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryOptInDirectTransfer(
    func: (call: token.OptInDirectTransferPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.OptInDirectTransferPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::opt_in_direct_transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferWithOptIn(
    func: (call: token.TransferWithOptInPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.TransferWithOptInPayload
    >,
  ): token {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token::transfer_with_opt_in",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDeposit(
    func: (event: token.DepositInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.DepositInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::Deposit" },
      handlerOptions,
    );
    return this;
  }

  onEventDepositEvent(
    func: (event: token.DepositEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.DepositEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::DepositEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdraw(
    func: (event: token.WithdrawInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.WithdrawInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::Withdraw" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawEvent(
    func: (event: token.WithdrawEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.WithdrawEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::WithdrawEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventBurn(
    func: (event: token.BurnInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.BurnInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::Burn" },
      handlerOptions,
    );
    return this;
  }

  onEventBurnToken(
    func: (event: token.BurnTokenInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.BurnTokenInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::BurnToken" },
      handlerOptions,
    );
    return this;
  }

  onEventBurnTokenEvent(
    func: (event: token.BurnTokenEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.BurnTokenEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::BurnTokenEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateCollection(
    func: (event: token.CreateCollectionInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.CreateCollectionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::CreateCollection" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateCollectionEvent(
    func: (
      event: token.CreateCollectionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.CreateCollectionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::CreateCollectionEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateTokenData(
    func: (event: token.CreateTokenDataInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.CreateTokenDataInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::CreateTokenData" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateTokenDataEvent(
    func: (
      event: token.CreateTokenDataEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.CreateTokenDataEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::CreateTokenDataEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventMint(
    func: (event: token.MintInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.MintInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::Mint" },
      handlerOptions,
    );
    return this;
  }

  onEventMintToken(
    func: (event: token.MintTokenInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, token.MintTokenInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::MintToken" },
      handlerOptions,
    );
    return this;
  }

  onEventMintTokenEvent(
    func: (event: token.MintTokenEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.MintTokenEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::MintTokenEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventMutatePropertyMap(
    func: (event: token.MutatePropertyMapInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.MutatePropertyMapInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::MutatePropertyMap" },
      handlerOptions,
    );
    return this;
  }

  onEventMutateTokenPropertyMap(
    func: (
      event: token.MutateTokenPropertyMapInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.MutateTokenPropertyMapInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::MutateTokenPropertyMap" },
      handlerOptions,
    );
    return this;
  }

  onEventMutateTokenPropertyMapEvent(
    func: (
      event: token.MutateTokenPropertyMapEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.MutateTokenPropertyMapEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::MutateTokenPropertyMapEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenDataCreation(
    func: (event: token.TokenDataCreationInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.TokenDataCreationInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::TokenDataCreation" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenDeposit(
    func: (event: token.TokenDepositInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.TokenDepositInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::TokenDeposit" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenWithdraw(
    func: (event: token.TokenWithdrawInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.TokenWithdrawInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::TokenWithdraw" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawCapability(
    func: (event: token.WithdrawCapabilityInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token.WithdrawCapabilityInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token::WithdrawCapability" },
      handlerOptions,
    );
    return this;
  }
}

export namespace token {
  export interface Deposit {
    id: token.TokenId;
    amount: bigint;
  }

  export namespace Deposit {
    export const TYPE_QNAME = "0x3::token::Deposit";

    const TYPE = new TypeDescriptor<Deposit>(Deposit.TYPE_QNAME);

    export function type(): TypeDescriptor<Deposit> {
      return TYPE.apply();
    }
  }

  export type DepositInstance = TypedEventInstance<Deposit> & {
    data_decoded: Deposit;
    type_arguments: [];
  };

  export interface DepositEvent {
    id: token.TokenId;
    amount: bigint;
  }

  export namespace DepositEvent {
    export const TYPE_QNAME = "0x3::token::DepositEvent";

    const TYPE = new TypeDescriptor<DepositEvent>(DepositEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<DepositEvent> {
      return TYPE.apply();
    }
  }

  export type DepositEventInstance = TypedEventInstance<DepositEvent> & {
    data_decoded: DepositEvent;
    type_arguments: [];
  };

  export interface Withdraw {
    id: token.TokenId;
    amount: bigint;
  }

  export namespace Withdraw {
    export const TYPE_QNAME = "0x3::token::Withdraw";

    const TYPE = new TypeDescriptor<Withdraw>(Withdraw.TYPE_QNAME);

    export function type(): TypeDescriptor<Withdraw> {
      return TYPE.apply();
    }
  }

  export type WithdrawInstance = TypedEventInstance<Withdraw> & {
    data_decoded: Withdraw;
    type_arguments: [];
  };

  export interface WithdrawEvent {
    id: token.TokenId;
    amount: bigint;
  }

  export namespace WithdrawEvent {
    export const TYPE_QNAME = "0x3::token::WithdrawEvent";

    const TYPE = new TypeDescriptor<WithdrawEvent>(WithdrawEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<WithdrawEvent> {
      return TYPE.apply();
    }
  }

  export type WithdrawEventInstance = TypedEventInstance<WithdrawEvent> & {
    data_decoded: WithdrawEvent;
    type_arguments: [];
  };

  export interface Burn {
    account: MoveAddressType;
    id: token.TokenId;
    amount: bigint;
  }

  export namespace Burn {
    export const TYPE_QNAME = "0x3::token::Burn";

    const TYPE = new TypeDescriptor<Burn>(Burn.TYPE_QNAME);

    export function type(): TypeDescriptor<Burn> {
      return TYPE.apply();
    }
  }

  export type BurnInstance = TypedEventInstance<Burn> & {
    data_decoded: Burn;
    type_arguments: [];
  };

  export interface BurnToken {
    id: token.TokenId;
    amount: bigint;
  }

  export namespace BurnToken {
    export const TYPE_QNAME = "0x3::token::BurnToken";

    const TYPE = new TypeDescriptor<BurnToken>(BurnToken.TYPE_QNAME);

    export function type(): TypeDescriptor<BurnToken> {
      return TYPE.apply();
    }
  }

  export type BurnTokenInstance = TypedEventInstance<BurnToken> & {
    data_decoded: BurnToken;
    type_arguments: [];
  };

  export interface BurnTokenEvent {
    id: token.TokenId;
    amount: bigint;
  }

  export namespace BurnTokenEvent {
    export const TYPE_QNAME = "0x3::token::BurnTokenEvent";

    const TYPE = new TypeDescriptor<BurnTokenEvent>(BurnTokenEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<BurnTokenEvent> {
      return TYPE.apply();
    }
  }

  export type BurnTokenEventInstance = TypedEventInstance<BurnTokenEvent> & {
    data_decoded: BurnTokenEvent;
    type_arguments: [];
  };

  export interface CollectionData {
    description: string;
    name: string;
    uri: string;
    supply: bigint;
    maximum: bigint;
    mutability_config: token.CollectionMutabilityConfig;
  }

  export namespace CollectionData {
    export const TYPE_QNAME = "0x3::token::CollectionData";

    const TYPE = new TypeDescriptor<CollectionData>(CollectionData.TYPE_QNAME);

    export function type(): TypeDescriptor<CollectionData> {
      return TYPE.apply();
    }
  }

  export interface CollectionMutabilityConfig {
    description: boolean;
    uri: boolean;
    maximum: boolean;
  }

  export namespace CollectionMutabilityConfig {
    export const TYPE_QNAME = "0x3::token::CollectionMutabilityConfig";

    const TYPE = new TypeDescriptor<CollectionMutabilityConfig>(
      CollectionMutabilityConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionMutabilityConfig> {
      return TYPE.apply();
    }
  }

  export 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>;
  }

  export namespace Collections {
    export const TYPE_QNAME = "0x3::token::Collections";

    const TYPE = new TypeDescriptor<Collections>(Collections.TYPE_QNAME);

    export function type(): TypeDescriptor<Collections> {
      return TYPE.apply();
    }
  }

  export interface CreateCollection {
    creator: MoveAddressType;
    collection_name: string;
    uri: string;
    description: string;
    maximum: bigint;
  }

  export namespace CreateCollection {
    export const TYPE_QNAME = "0x3::token::CreateCollection";

    const TYPE = new TypeDescriptor<CreateCollection>(
      CreateCollection.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateCollection> {
      return TYPE.apply();
    }
  }

  export type CreateCollectionInstance =
    TypedEventInstance<CreateCollection> & {
      data_decoded: CreateCollection;
      type_arguments: [];
    };

  export interface CreateCollectionEvent {
    creator: MoveAddressType;
    collection_name: string;
    uri: string;
    description: string;
    maximum: bigint;
  }

  export namespace CreateCollectionEvent {
    export const TYPE_QNAME = "0x3::token::CreateCollectionEvent";

    const TYPE = new TypeDescriptor<CreateCollectionEvent>(
      CreateCollectionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateCollectionEvent> {
      return TYPE.apply();
    }
  }

  export type CreateCollectionEventInstance =
    TypedEventInstance<CreateCollectionEvent> & {
      data_decoded: CreateCollectionEvent;
      type_arguments: [];
    };

  export 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[];
  }

  export namespace CreateTokenData {
    export const TYPE_QNAME = "0x3::token::CreateTokenData";

    const TYPE = new TypeDescriptor<CreateTokenData>(
      CreateTokenData.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateTokenData> {
      return TYPE.apply();
    }
  }

  export type CreateTokenDataInstance = TypedEventInstance<CreateTokenData> & {
    data_decoded: CreateTokenData;
    type_arguments: [];
  };

  export 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[];
  }

  export namespace CreateTokenDataEvent {
    export const TYPE_QNAME = "0x3::token::CreateTokenDataEvent";

    const TYPE = new TypeDescriptor<CreateTokenDataEvent>(
      CreateTokenDataEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateTokenDataEvent> {
      return TYPE.apply();
    }
  }

  export type CreateTokenDataEventInstance =
    TypedEventInstance<CreateTokenDataEvent> & {
      data_decoded: CreateTokenDataEvent;
      type_arguments: [];
    };

  export interface Mint {
    creator: MoveAddressType;
    id: token.TokenDataId;
    amount: bigint;
  }

  export namespace Mint {
    export const TYPE_QNAME = "0x3::token::Mint";

    const TYPE = new TypeDescriptor<Mint>(Mint.TYPE_QNAME);

    export function type(): TypeDescriptor<Mint> {
      return TYPE.apply();
    }
  }

  export type MintInstance = TypedEventInstance<Mint> & {
    data_decoded: Mint;
    type_arguments: [];
  };

  export interface MintToken {
    id: token.TokenDataId;
    amount: bigint;
  }

  export namespace MintToken {
    export const TYPE_QNAME = "0x3::token::MintToken";

    const TYPE = new TypeDescriptor<MintToken>(MintToken.TYPE_QNAME);

    export function type(): TypeDescriptor<MintToken> {
      return TYPE.apply();
    }
  }

  export type MintTokenInstance = TypedEventInstance<MintToken> & {
    data_decoded: MintToken;
    type_arguments: [];
  };

  export interface MintTokenEvent {
    id: token.TokenDataId;
    amount: bigint;
  }

  export namespace MintTokenEvent {
    export const TYPE_QNAME = "0x3::token::MintTokenEvent";

    const TYPE = new TypeDescriptor<MintTokenEvent>(MintTokenEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<MintTokenEvent> {
      return TYPE.apply();
    }
  }

  export type MintTokenEventInstance = TypedEventInstance<MintTokenEvent> & {
    data_decoded: MintTokenEvent;
    type_arguments: [];
  };

  export interface MutatePropertyMap {
    account: MoveAddressType;
    old_id: token.TokenId;
    new_id: token.TokenId;
    keys: string[];
    values: string[];
    types: string[];
  }

  export namespace MutatePropertyMap {
    export const TYPE_QNAME = "0x3::token::MutatePropertyMap";

    const TYPE = new TypeDescriptor<MutatePropertyMap>(
      MutatePropertyMap.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MutatePropertyMap> {
      return TYPE.apply();
    }
  }

  export type MutatePropertyMapInstance =
    TypedEventInstance<MutatePropertyMap> & {
      data_decoded: MutatePropertyMap;
      type_arguments: [];
    };

  export interface MutateTokenPropertyMap {
    old_id: token.TokenId;
    new_id: token.TokenId;
    keys: string[];
    values: string[];
    types: string[];
  }

  export namespace MutateTokenPropertyMap {
    export const TYPE_QNAME = "0x3::token::MutateTokenPropertyMap";

    const TYPE = new TypeDescriptor<MutateTokenPropertyMap>(
      MutateTokenPropertyMap.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MutateTokenPropertyMap> {
      return TYPE.apply();
    }
  }

  export type MutateTokenPropertyMapInstance =
    TypedEventInstance<MutateTokenPropertyMap> & {
      data_decoded: MutateTokenPropertyMap;
      type_arguments: [];
    };

  export interface MutateTokenPropertyMapEvent {
    old_id: token.TokenId;
    new_id: token.TokenId;
    keys: string[];
    values: string[];
    types: string[];
  }

  export namespace MutateTokenPropertyMapEvent {
    export const TYPE_QNAME = "0x3::token::MutateTokenPropertyMapEvent";

    const TYPE = new TypeDescriptor<MutateTokenPropertyMapEvent>(
      MutateTokenPropertyMapEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MutateTokenPropertyMapEvent> {
      return TYPE.apply();
    }
  }

  export type MutateTokenPropertyMapEventInstance =
    TypedEventInstance<MutateTokenPropertyMapEvent> & {
      data_decoded: MutateTokenPropertyMapEvent;
      type_arguments: [];
    };

  export interface Royalty {
    royalty_points_numerator: bigint;
    royalty_points_denominator: bigint;
    payee_address: MoveAddressType;
  }

  export namespace Royalty {
    export const TYPE_QNAME = "0x3::token::Royalty";

    const TYPE = new TypeDescriptor<Royalty>(Royalty.TYPE_QNAME);

    export function type(): TypeDescriptor<Royalty> {
      return TYPE.apply();
    }
  }

  export interface Token {
    id: token.TokenId;
    amount: bigint;
    token_properties: property_map.PropertyMap;
  }

  export namespace Token {
    export const TYPE_QNAME = "0x3::token::Token";

    const TYPE = new TypeDescriptor<Token>(Token.TYPE_QNAME);

    export function type(): TypeDescriptor<Token> {
      return TYPE.apply();
    }
  }

  export 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;
  }

  export namespace TokenData {
    export const TYPE_QNAME = "0x3::token::TokenData";

    const TYPE = new TypeDescriptor<TokenData>(TokenData.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenData> {
      return TYPE.apply();
    }
  }

  export 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[];
  }

  export namespace TokenDataCreation {
    export const TYPE_QNAME = "0x3::token::TokenDataCreation";

    const TYPE = new TypeDescriptor<TokenDataCreation>(
      TokenDataCreation.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenDataCreation> {
      return TYPE.apply();
    }
  }

  export type TokenDataCreationInstance =
    TypedEventInstance<TokenDataCreation> & {
      data_decoded: TokenDataCreation;
      type_arguments: [];
    };

  export interface TokenDataId {
    creator: MoveAddressType;
    collection: string;
    name: string;
  }

  export namespace TokenDataId {
    export const TYPE_QNAME = "0x3::token::TokenDataId";

    const TYPE = new TypeDescriptor<TokenDataId>(TokenDataId.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenDataId> {
      return TYPE.apply();
    }
  }

  export interface TokenDeposit {
    account: MoveAddressType;
    id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenDeposit {
    export const TYPE_QNAME = "0x3::token::TokenDeposit";

    const TYPE = new TypeDescriptor<TokenDeposit>(TokenDeposit.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenDeposit> {
      return TYPE.apply();
    }
  }

  export type TokenDepositInstance = TypedEventInstance<TokenDeposit> & {
    data_decoded: TokenDeposit;
    type_arguments: [];
  };

  export interface TokenId {
    token_data_id: token.TokenDataId;
    property_version: bigint;
  }

  export namespace TokenId {
    export const TYPE_QNAME = "0x3::token::TokenId";

    const TYPE = new TypeDescriptor<TokenId>(TokenId.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenId> {
      return TYPE.apply();
    }
  }

  export interface TokenMutabilityConfig {
    maximum: boolean;
    uri: boolean;
    royalty: boolean;
    description: boolean;
    properties: boolean;
  }

  export namespace TokenMutabilityConfig {
    export const TYPE_QNAME = "0x3::token::TokenMutabilityConfig";

    const TYPE = new TypeDescriptor<TokenMutabilityConfig>(
      TokenMutabilityConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenMutabilityConfig> {
      return TYPE.apply();
    }
  }

  export 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>;
  }

  export namespace TokenStore {
    export const TYPE_QNAME = "0x3::token::TokenStore";

    const TYPE = new TypeDescriptor<TokenStore>(TokenStore.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenStore> {
      return TYPE.apply();
    }
  }

  export interface TokenWithdraw {
    account: MoveAddressType;
    id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenWithdraw {
    export const TYPE_QNAME = "0x3::token::TokenWithdraw";

    const TYPE = new TypeDescriptor<TokenWithdraw>(TokenWithdraw.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenWithdraw> {
      return TYPE.apply();
    }
  }

  export type TokenWithdrawInstance = TypedEventInstance<TokenWithdraw> & {
    data_decoded: TokenWithdraw;
    type_arguments: [];
  };

  export interface WithdrawCapability {
    token_owner: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
    expiration_sec: bigint;
  }

  export namespace WithdrawCapability {
    export const TYPE_QNAME = "0x3::token::WithdrawCapability";

    const TYPE = new TypeDescriptor<WithdrawCapability>(
      WithdrawCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<WithdrawCapability> {
      return TYPE.apply();
    }
  }

  export type WithdrawCapabilityInstance =
    TypedEventInstance<WithdrawCapability> & {
      data_decoded: WithdrawCapability;
      type_arguments: [];
    };

  export namespace entry {
    export async function burn(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string, bigint, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::burn",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function burnByCreator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string, bigint, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::burn_by_creator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function createCollectionScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string, string, bigint, boolean[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::create_collection_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async 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> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::create_token_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function directTransferScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType,
          string,
          string,
          bigint,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::direct_transfer_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function initializeTokenScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::initialize_token_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function mintScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::mint_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function mutateTokenProperties(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType,
          string,
          string,
          bigint,
          bigint,
          string[],
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::mutate_token_properties",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function optInDirectTransfer(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::opt_in_direct_transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function transferWithOptIn(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          string,
          string,
          bigint,
          MoveAddressType,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token::transfer_with_opt_in",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function getCollectionMutabilityConfig(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, string];
      },
      version?: bigint,
    ): Promise<[token.CollectionMutabilityConfig]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x3::token::get_collection_mutability_config",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x3::token::get_collection_mutability_config",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface BurnPayload
    extends TypedFunctionPayload<
      [MoveAddressType, string, string, bigint, bigint]
    > {
    arguments_decoded: [MoveAddressType, string, string, bigint, bigint];
    type_arguments: [];
  }

  export interface BurnByCreatorPayload
    extends TypedFunctionPayload<
      [MoveAddressType, string, string, bigint, bigint]
    > {
    arguments_decoded: [MoveAddressType, string, string, bigint, bigint];
    type_arguments: [];
  }

  export interface CreateCollectionScriptPayload
    extends TypedFunctionPayload<[string, string, string, bigint, boolean[]]> {
    arguments_decoded: [string, string, string, bigint, boolean[]];
    type_arguments: [];
  }

  export 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: [];
  }

  export interface DirectTransferScriptPayload
    extends TypedFunctionPayload<
      [MoveAddressType, MoveAddressType, string, string, bigint, bigint]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType,
      string,
      string,
      bigint,
      bigint,
    ];
    type_arguments: [];
  }

  export interface InitializeTokenScriptPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface MintScriptPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string, bigint]> {
    arguments_decoded: [MoveAddressType, string, string, bigint];
    type_arguments: [];
  }

  export 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: [];
  }

  export interface OptInDirectTransferPayload
    extends TypedFunctionPayload<[boolean]> {
    arguments_decoded: [boolean];
    type_arguments: [];
  }

  export interface TransferWithOptInPayload
    extends TypedFunctionPayload<
      [MoveAddressType, string, string, bigint, MoveAddressType, bigint]
    > {
    arguments_decoded: [
      MoveAddressType,
      string,
      string,
      bigint,
      MoveAddressType,
      bigint,
    ];
    type_arguments: [];
  }
}

export namespace property_map {
  export interface PropertyMap {
    map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
  }

  export namespace PropertyMap {
    export const TYPE_QNAME = "0x3::property_map::PropertyMap";

    const TYPE = new TypeDescriptor<PropertyMap>(PropertyMap.TYPE_QNAME);

    export function type(): TypeDescriptor<PropertyMap> {
      return TYPE.apply();
    }
  }

  export interface PropertyValue {
    value: string;
    type: string;
  }

  export namespace PropertyValue {
    export const TYPE_QNAME = "0x3::property_map::PropertyValue";

    const TYPE = new TypeDescriptor<PropertyValue>(PropertyValue.TYPE_QNAME);

    export function type(): TypeDescriptor<PropertyValue> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class token_coin_swap extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("token_coin_swap", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x3",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): token_coin_swap {
    return new token_coin_swap({
      ...token_coin_swap.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryListTokenForSwap(
    func: (
      call: token_coin_swap.ListTokenForSwapPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_coin_swap.ListTokenForSwapPayload
    >,
  ): token_coin_swap {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token_coin_swap::list_token_for_swap",
      },
      handlerOptions,
    );
    return this;
  }

  onEventTokenCoinSwap(
    func: (
      event: token_coin_swap.TokenCoinSwapInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_coin_swap.TokenCoinSwapInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_coin_swap {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_coin_swap::TokenCoinSwap" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenListingEvent(
    func: (
      event: token_coin_swap.TokenListingEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_coin_swap.TokenListingEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_coin_swap {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_coin_swap::TokenListingEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenSwapEvent(
    func: (
      event: token_coin_swap.TokenSwapEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_coin_swap.TokenSwapEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_coin_swap {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_coin_swap::TokenSwapEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace token_coin_swap {
  export interface TokenCoinSwap<T0> {
    token_amount: bigint;
    min_price_per_token: bigint;
  }

  export namespace TokenCoinSwap {
    export const TYPE_QNAME = "0x3::token_coin_swap::TokenCoinSwap";

    const TYPE = new TypeDescriptor<TokenCoinSwap<any>>(
      TokenCoinSwap.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<TokenCoinSwap<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export type TokenCoinSwapInstance = TypedEventInstance<TokenCoinSwap<any>> & {
    data_decoded: TokenCoinSwap<any>;
    type_arguments: [string];
  };

  export interface TokenEscrow {
    token: token.Token;
    locked_until_secs: bigint;
  }

  export namespace TokenEscrow {
    export const TYPE_QNAME = "0x3::token_coin_swap::TokenEscrow";

    const TYPE = new TypeDescriptor<TokenEscrow>(TokenEscrow.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenEscrow> {
      return TYPE.apply();
    }
  }

  export interface TokenListingEvent {
    token_id: token.TokenId;
    amount: bigint;
    min_price: bigint;
    locked_until_secs: bigint;
    coin_type_info: _0x1.type_info.TypeInfo;
  }

  export namespace TokenListingEvent {
    export const TYPE_QNAME = "0x3::token_coin_swap::TokenListingEvent";

    const TYPE = new TypeDescriptor<TokenListingEvent>(
      TokenListingEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenListingEvent> {
      return TYPE.apply();
    }
  }

  export type TokenListingEventInstance =
    TypedEventInstance<TokenListingEvent> & {
      data_decoded: TokenListingEvent;
      type_arguments: [];
    };

  export 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>;
  }

  export namespace TokenListings {
    export const TYPE_QNAME = "0x3::token_coin_swap::TokenListings";

    const TYPE = new TypeDescriptor<TokenListings<any>>(
      TokenListings.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<TokenListings<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface TokenStoreEscrow {
    token_escrows: _0x1.table.Table<token.TokenId, token_coin_swap.TokenEscrow>;
  }

  export namespace TokenStoreEscrow {
    export const TYPE_QNAME = "0x3::token_coin_swap::TokenStoreEscrow";

    const TYPE = new TypeDescriptor<TokenStoreEscrow>(
      TokenStoreEscrow.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenStoreEscrow> {
      return TYPE.apply();
    }
  }

  export interface TokenSwapEvent {
    token_id: token.TokenId;
    token_buyer: MoveAddressType;
    token_amount: bigint;
    coin_amount: bigint;
    coin_type_info: _0x1.type_info.TypeInfo;
  }

  export namespace TokenSwapEvent {
    export const TYPE_QNAME = "0x3::token_coin_swap::TokenSwapEvent";

    const TYPE = new TypeDescriptor<TokenSwapEvent>(TokenSwapEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenSwapEvent> {
      return TYPE.apply();
    }
  }

  export type TokenSwapEventInstance = TypedEventInstance<TokenSwapEvent> & {
    data_decoded: TokenSwapEvent;
    type_arguments: [];
  };

  export namespace entry {
    export async function listTokenForSwap<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [
          MoveAddressType,
          string,
          string,
          bigint,
          bigint,
          bigint,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token_coin_swap::list_token_for_swap",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export 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 class token_transfers extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("token_transfers", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x3",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): token_transfers {
    return new token_transfers({
      ...token_transfers.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryCancelOfferScript(
    func: (
      call: token_transfers.CancelOfferScriptPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.CancelOfferScriptPayload
    >,
  ): token_transfers {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token_transfers::cancel_offer_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryClaimScript(
    func: (call: token_transfers.ClaimScriptPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.ClaimScriptPayload
    >,
  ): token_transfers {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token_transfers::claim_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryOfferScript(
    func: (call: token_transfers.OfferScriptPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.OfferScriptPayload
    >,
  ): token_transfers {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "token_transfers::offer_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCancelOffer(
    func: (
      event: token_transfers.CancelOfferInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.CancelOfferInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::CancelOffer" },
      handlerOptions,
    );
    return this;
  }

  onEventClaim(
    func: (event: token_transfers.ClaimInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.ClaimInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::Claim" },
      handlerOptions,
    );
    return this;
  }

  onEventOffer(
    func: (event: token_transfers.OfferInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.OfferInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::Offer" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenCancelOffer(
    func: (
      event: token_transfers.TokenCancelOfferInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenCancelOfferInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::TokenCancelOffer" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenCancelOfferEvent(
    func: (
      event: token_transfers.TokenCancelOfferEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenCancelOfferEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_transfers::TokenCancelOfferEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventTokenClaim(
    func: (
      event: token_transfers.TokenClaimInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenClaimInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::TokenClaim" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenClaimEvent(
    func: (
      event: token_transfers.TokenClaimEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenClaimEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::TokenClaimEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenOffer(
    func: (
      event: token_transfers.TokenOfferInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenOfferInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::TokenOffer" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenOfferEvent(
    func: (
      event: token_transfers.TokenOfferEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenOfferEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::TokenOfferEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTokenOfferId(
    func: (
      event: token_transfers.TokenOfferIdInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_transfers.TokenOfferIdInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_transfers {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_transfers::TokenOfferId" },
      handlerOptions,
    );
    return this;
  }
}

export namespace token_transfers {
  export interface CancelOffer {
    account: MoveAddressType;
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace CancelOffer {
    export const TYPE_QNAME = "0x3::token_transfers::CancelOffer";

    const TYPE = new TypeDescriptor<CancelOffer>(CancelOffer.TYPE_QNAME);

    export function type(): TypeDescriptor<CancelOffer> {
      return TYPE.apply();
    }
  }

  export type CancelOfferInstance = TypedEventInstance<CancelOffer> & {
    data_decoded: CancelOffer;
    type_arguments: [];
  };

  export interface Claim {
    account: MoveAddressType;
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace Claim {
    export const TYPE_QNAME = "0x3::token_transfers::Claim";

    const TYPE = new TypeDescriptor<Claim>(Claim.TYPE_QNAME);

    export function type(): TypeDescriptor<Claim> {
      return TYPE.apply();
    }
  }

  export type ClaimInstance = TypedEventInstance<Claim> & {
    data_decoded: Claim;
    type_arguments: [];
  };

  export interface Offer {
    account: MoveAddressType;
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace Offer {
    export const TYPE_QNAME = "0x3::token_transfers::Offer";

    const TYPE = new TypeDescriptor<Offer>(Offer.TYPE_QNAME);

    export function type(): TypeDescriptor<Offer> {
      return TYPE.apply();
    }
  }

  export type OfferInstance = TypedEventInstance<Offer> & {
    data_decoded: Offer;
    type_arguments: [];
  };

  export 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>;
  }

  export namespace PendingClaims {
    export const TYPE_QNAME = "0x3::token_transfers::PendingClaims";

    const TYPE = new TypeDescriptor<PendingClaims>(PendingClaims.TYPE_QNAME);

    export function type(): TypeDescriptor<PendingClaims> {
      return TYPE.apply();
    }
  }

  export interface TokenCancelOffer {
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenCancelOffer {
    export const TYPE_QNAME = "0x3::token_transfers::TokenCancelOffer";

    const TYPE = new TypeDescriptor<TokenCancelOffer>(
      TokenCancelOffer.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenCancelOffer> {
      return TYPE.apply();
    }
  }

  export type TokenCancelOfferInstance =
    TypedEventInstance<TokenCancelOffer> & {
      data_decoded: TokenCancelOffer;
      type_arguments: [];
    };

  export interface TokenCancelOfferEvent {
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenCancelOfferEvent {
    export const TYPE_QNAME = "0x3::token_transfers::TokenCancelOfferEvent";

    const TYPE = new TypeDescriptor<TokenCancelOfferEvent>(
      TokenCancelOfferEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenCancelOfferEvent> {
      return TYPE.apply();
    }
  }

  export type TokenCancelOfferEventInstance =
    TypedEventInstance<TokenCancelOfferEvent> & {
      data_decoded: TokenCancelOfferEvent;
      type_arguments: [];
    };

  export interface TokenClaim {
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenClaim {
    export const TYPE_QNAME = "0x3::token_transfers::TokenClaim";

    const TYPE = new TypeDescriptor<TokenClaim>(TokenClaim.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenClaim> {
      return TYPE.apply();
    }
  }

  export type TokenClaimInstance = TypedEventInstance<TokenClaim> & {
    data_decoded: TokenClaim;
    type_arguments: [];
  };

  export interface TokenClaimEvent {
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenClaimEvent {
    export const TYPE_QNAME = "0x3::token_transfers::TokenClaimEvent";

    const TYPE = new TypeDescriptor<TokenClaimEvent>(
      TokenClaimEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenClaimEvent> {
      return TYPE.apply();
    }
  }

  export type TokenClaimEventInstance = TypedEventInstance<TokenClaimEvent> & {
    data_decoded: TokenClaimEvent;
    type_arguments: [];
  };

  export interface TokenOffer {
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenOffer {
    export const TYPE_QNAME = "0x3::token_transfers::TokenOffer";

    const TYPE = new TypeDescriptor<TokenOffer>(TokenOffer.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenOffer> {
      return TYPE.apply();
    }
  }

  export type TokenOfferInstance = TypedEventInstance<TokenOffer> & {
    data_decoded: TokenOffer;
    type_arguments: [];
  };

  export interface TokenOfferEvent {
    to_address: MoveAddressType;
    token_id: token.TokenId;
    amount: bigint;
  }

  export namespace TokenOfferEvent {
    export const TYPE_QNAME = "0x3::token_transfers::TokenOfferEvent";

    const TYPE = new TypeDescriptor<TokenOfferEvent>(
      TokenOfferEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenOfferEvent> {
      return TYPE.apply();
    }
  }

  export type TokenOfferEventInstance = TypedEventInstance<TokenOfferEvent> & {
    data_decoded: TokenOfferEvent;
    type_arguments: [];
  };

  export interface TokenOfferId {
    to_addr: MoveAddressType;
    token_id: token.TokenId;
  }

  export namespace TokenOfferId {
    export const TYPE_QNAME = "0x3::token_transfers::TokenOfferId";

    const TYPE = new TypeDescriptor<TokenOfferId>(TokenOfferId.TYPE_QNAME);

    export function type(): TypeDescriptor<TokenOfferId> {
      return TYPE.apply();
    }
  }

  export type TokenOfferIdInstance = TypedEventInstance<TokenOfferId> & {
    data_decoded: TokenOfferId;
    type_arguments: [];
  };

  export namespace entry {
    export async function cancelOfferScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType,
          MoveAddressType,
          string,
          string,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token_transfers::cancel_offer_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function claimScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType,
          MoveAddressType,
          string,
          string,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token_transfers::claim_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function offerScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType,
          MoveAddressType,
          string,
          string,
          bigint,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x3::token_transfers::offer_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface CancelOfferScriptPayload
    extends TypedFunctionPayload<
      [
        MoveAddressType,
        MoveAddressType,
        MoveAddressType,
        string,
        string,
        bigint,
      ]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType,
      MoveAddressType,
      string,
      string,
      bigint,
    ];
    type_arguments: [];
  }

  export interface ClaimScriptPayload
    extends TypedFunctionPayload<
      [
        MoveAddressType,
        MoveAddressType,
        MoveAddressType,
        string,
        string,
        bigint,
      ]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType,
      MoveAddressType,
      string,
      string,
      bigint,
    ];
    type_arguments: [];
  }

  export interface OfferScriptPayload
    extends TypedFunctionPayload<
      [
        MoveAddressType,
        MoveAddressType,
        MoveAddressType,
        string,
        string,
        bigint,
        bigint,
      ]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType,
      MoveAddressType,
      string,
      string,
      bigint,
      bigint,
    ];
    type_arguments: [];
  }
}

export class token_event_store extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("token_event_store", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x3",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): token_event_store {
    return new token_event_store({
      ...token_event_store.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEventCollectionDescriptionMutate(
    func: (
      event: token_event_store.CollectionDescriptionMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionDescriptionMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionDescriptionMutate",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCollectionDescriptionMutateEvent(
    func: (
      event: token_event_store.CollectionDescriptionMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionDescriptionMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionDescriptionMutateEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCollectionMaximumMutate(
    func: (
      event: token_event_store.CollectionMaximumMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionMaximumMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionMaximumMutate",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCollectionMaxiumMutate(
    func: (
      event: token_event_store.CollectionMaxiumMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionMaxiumMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionMaxiumMutate",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCollectionMaxiumMutateEvent(
    func: (
      event: token_event_store.CollectionMaxiumMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionMaxiumMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionMaxiumMutateEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCollectionUriMutate(
    func: (
      event: token_event_store.CollectionUriMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionUriMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionUriMutate",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCollectionUriMutateEvent(
    func: (
      event: token_event_store.CollectionUriMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.CollectionUriMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::CollectionUriMutateEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDefaultPropertyMutate(
    func: (
      event: token_event_store.DefaultPropertyMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.DefaultPropertyMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::DefaultPropertyMutate",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDefaultPropertyMutateEvent(
    func: (
      event: token_event_store.DefaultPropertyMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.DefaultPropertyMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::DefaultPropertyMutateEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDescriptionMutate(
    func: (
      event: token_event_store.DescriptionMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.DescriptionMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::DescriptionMutate" },
      handlerOptions,
    );
    return this;
  }

  onEventDescriptionMutateEvent(
    func: (
      event: token_event_store.DescriptionMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.DescriptionMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "token_event_store::DescriptionMutateEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventMaximumMutate(
    func: (
      event: token_event_store.MaximumMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.MaximumMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::MaximumMutate" },
      handlerOptions,
    );
    return this;
  }

  onEventMaxiumMutateEvent(
    func: (
      event: token_event_store.MaxiumMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.MaxiumMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::MaxiumMutateEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventOptInTransfer(
    func: (
      event: token_event_store.OptInTransferInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.OptInTransferInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::OptInTransfer" },
      handlerOptions,
    );
    return this;
  }

  onEventOptInTransferEvent(
    func: (
      event: token_event_store.OptInTransferEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.OptInTransferEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::OptInTransferEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventRoyaltyMutate(
    func: (
      event: token_event_store.RoyaltyMutateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.RoyaltyMutateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::RoyaltyMutate" },
      handlerOptions,
    );
    return this;
  }

  onEventRoyaltyMutateEvent(
    func: (
      event: token_event_store.RoyaltyMutateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.RoyaltyMutateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::RoyaltyMutateEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUriMutation(
    func: (
      event: token_event_store.UriMutationInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.UriMutationInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::UriMutation" },
      handlerOptions,
    );
    return this;
  }

  onEventUriMutationEvent(
    func: (
      event: token_event_store.UriMutationEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      token_event_store.UriMutationEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): token_event_store {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "token_event_store::UriMutationEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace token_event_store {
  export interface CollectionDescriptionMutate {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_description: string;
    new_description: string;
  }

  export namespace CollectionDescriptionMutate {
    export const TYPE_QNAME =
      "0x3::token_event_store::CollectionDescriptionMutate";

    const TYPE = new TypeDescriptor<CollectionDescriptionMutate>(
      CollectionDescriptionMutate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionDescriptionMutate> {
      return TYPE.apply();
    }
  }

  export type CollectionDescriptionMutateInstance =
    TypedEventInstance<CollectionDescriptionMutate> & {
      data_decoded: CollectionDescriptionMutate;
      type_arguments: [];
    };

  export interface CollectionDescriptionMutateEvent {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_description: string;
    new_description: string;
  }

  export namespace CollectionDescriptionMutateEvent {
    export const TYPE_QNAME =
      "0x3::token_event_store::CollectionDescriptionMutateEvent";

    const TYPE = new TypeDescriptor<CollectionDescriptionMutateEvent>(
      CollectionDescriptionMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionDescriptionMutateEvent> {
      return TYPE.apply();
    }
  }

  export type CollectionDescriptionMutateEventInstance =
    TypedEventInstance<CollectionDescriptionMutateEvent> & {
      data_decoded: CollectionDescriptionMutateEvent;
      type_arguments: [];
    };

  export interface CollectionMaximumMutate {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_maximum: bigint;
    new_maximum: bigint;
  }

  export namespace CollectionMaximumMutate {
    export const TYPE_QNAME = "0x3::token_event_store::CollectionMaximumMutate";

    const TYPE = new TypeDescriptor<CollectionMaximumMutate>(
      CollectionMaximumMutate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionMaximumMutate> {
      return TYPE.apply();
    }
  }

  export type CollectionMaximumMutateInstance =
    TypedEventInstance<CollectionMaximumMutate> & {
      data_decoded: CollectionMaximumMutate;
      type_arguments: [];
    };

  export interface CollectionMaxiumMutate {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_maximum: bigint;
    new_maximum: bigint;
  }

  export namespace CollectionMaxiumMutate {
    export const TYPE_QNAME = "0x3::token_event_store::CollectionMaxiumMutate";

    const TYPE = new TypeDescriptor<CollectionMaxiumMutate>(
      CollectionMaxiumMutate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionMaxiumMutate> {
      return TYPE.apply();
    }
  }

  export type CollectionMaxiumMutateInstance =
    TypedEventInstance<CollectionMaxiumMutate> & {
      data_decoded: CollectionMaxiumMutate;
      type_arguments: [];
    };

  export interface CollectionMaxiumMutateEvent {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_maximum: bigint;
    new_maximum: bigint;
  }

  export namespace CollectionMaxiumMutateEvent {
    export const TYPE_QNAME =
      "0x3::token_event_store::CollectionMaxiumMutateEvent";

    const TYPE = new TypeDescriptor<CollectionMaxiumMutateEvent>(
      CollectionMaxiumMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionMaxiumMutateEvent> {
      return TYPE.apply();
    }
  }

  export type CollectionMaxiumMutateEventInstance =
    TypedEventInstance<CollectionMaxiumMutateEvent> & {
      data_decoded: CollectionMaxiumMutateEvent;
      type_arguments: [];
    };

  export interface CollectionUriMutate {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_uri: string;
    new_uri: string;
  }

  export namespace CollectionUriMutate {
    export const TYPE_QNAME = "0x3::token_event_store::CollectionUriMutate";

    const TYPE = new TypeDescriptor<CollectionUriMutate>(
      CollectionUriMutate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionUriMutate> {
      return TYPE.apply();
    }
  }

  export type CollectionUriMutateInstance =
    TypedEventInstance<CollectionUriMutate> & {
      data_decoded: CollectionUriMutate;
      type_arguments: [];
    };

  export interface CollectionUriMutateEvent {
    creator_addr: MoveAddressType;
    collection_name: string;
    old_uri: string;
    new_uri: string;
  }

  export namespace CollectionUriMutateEvent {
    export const TYPE_QNAME =
      "0x3::token_event_store::CollectionUriMutateEvent";

    const TYPE = new TypeDescriptor<CollectionUriMutateEvent>(
      CollectionUriMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectionUriMutateEvent> {
      return TYPE.apply();
    }
  }

  export type CollectionUriMutateEventInstance =
    TypedEventInstance<CollectionUriMutateEvent> & {
      data_decoded: CollectionUriMutateEvent;
      type_arguments: [];
    };

  export interface DefaultPropertyMutate {
    creator: MoveAddressType;
    collection: string;
    token: string;
    keys: string[];
    old_values: _0x1.option.Option<property_map.PropertyValue>[];
    new_values: property_map.PropertyValue[];
  }

  export namespace DefaultPropertyMutate {
    export const TYPE_QNAME = "0x3::token_event_store::DefaultPropertyMutate";

    const TYPE = new TypeDescriptor<DefaultPropertyMutate>(
      DefaultPropertyMutate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DefaultPropertyMutate> {
      return TYPE.apply();
    }
  }

  export type DefaultPropertyMutateInstance =
    TypedEventInstance<DefaultPropertyMutate> & {
      data_decoded: DefaultPropertyMutate;
      type_arguments: [];
    };

  export interface DefaultPropertyMutateEvent {
    creator: MoveAddressType;
    collection: string;
    token: string;
    keys: string[];
    old_values: _0x1.option.Option<property_map.PropertyValue>[];
    new_values: property_map.PropertyValue[];
  }

  export namespace DefaultPropertyMutateEvent {
    export const TYPE_QNAME =
      "0x3::token_event_store::DefaultPropertyMutateEvent";

    const TYPE = new TypeDescriptor<DefaultPropertyMutateEvent>(
      DefaultPropertyMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DefaultPropertyMutateEvent> {
      return TYPE.apply();
    }
  }

  export type DefaultPropertyMutateEventInstance =
    TypedEventInstance<DefaultPropertyMutateEvent> & {
      data_decoded: DefaultPropertyMutateEvent;
      type_arguments: [];
    };

  export interface DescriptionMutate {
    creator: MoveAddressType;
    collection: string;
    token: string;
    old_description: string;
    new_description: string;
  }

  export namespace DescriptionMutate {
    export const TYPE_QNAME = "0x3::token_event_store::DescriptionMutate";

    const TYPE = new TypeDescriptor<DescriptionMutate>(
      DescriptionMutate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DescriptionMutate> {
      return TYPE.apply();
    }
  }

  export type DescriptionMutateInstance =
    TypedEventInstance<DescriptionMutate> & {
      data_decoded: DescriptionMutate;
      type_arguments: [];
    };

  export interface DescriptionMutateEvent {
    creator: MoveAddressType;
    collection: string;
    token: string;
    old_description: string;
    new_description: string;
  }

  export namespace DescriptionMutateEvent {
    export const TYPE_QNAME = "0x3::token_event_store::DescriptionMutateEvent";

    const TYPE = new TypeDescriptor<DescriptionMutateEvent>(
      DescriptionMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DescriptionMutateEvent> {
      return TYPE.apply();
    }
  }

  export type DescriptionMutateEventInstance =
    TypedEventInstance<DescriptionMutateEvent> & {
      data_decoded: DescriptionMutateEvent;
      type_arguments: [];
    };

  export interface MaximumMutate {
    creator: MoveAddressType;
    collection: string;
    token: string;
    old_maximum: bigint;
    new_maximum: bigint;
  }

  export namespace MaximumMutate {
    export const TYPE_QNAME = "0x3::token_event_store::MaximumMutate";

    const TYPE = new TypeDescriptor<MaximumMutate>(MaximumMutate.TYPE_QNAME);

    export function type(): TypeDescriptor<MaximumMutate> {
      return TYPE.apply();
    }
  }

  export type MaximumMutateInstance = TypedEventInstance<MaximumMutate> & {
    data_decoded: MaximumMutate;
    type_arguments: [];
  };

  export interface MaxiumMutateEvent {
    creator: MoveAddressType;
    collection: string;
    token: string;
    old_maximum: bigint;
    new_maximum: bigint;
  }

  export namespace MaxiumMutateEvent {
    export const TYPE_QNAME = "0x3::token_event_store::MaxiumMutateEvent";

    const TYPE = new TypeDescriptor<MaxiumMutateEvent>(
      MaxiumMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MaxiumMutateEvent> {
      return TYPE.apply();
    }
  }

  export type MaxiumMutateEventInstance =
    TypedEventInstance<MaxiumMutateEvent> & {
      data_decoded: MaxiumMutateEvent;
      type_arguments: [];
    };

  export interface OptInTransfer {
    account_address: MoveAddressType;
    opt_in: boolean;
  }

  export namespace OptInTransfer {
    export const TYPE_QNAME = "0x3::token_event_store::OptInTransfer";

    const TYPE = new TypeDescriptor<OptInTransfer>(OptInTransfer.TYPE_QNAME);

    export function type(): TypeDescriptor<OptInTransfer> {
      return TYPE.apply();
    }
  }

  export type OptInTransferInstance = TypedEventInstance<OptInTransfer> & {
    data_decoded: OptInTransfer;
    type_arguments: [];
  };

  export interface OptInTransferEvent {
    opt_in: boolean;
  }

  export namespace OptInTransferEvent {
    export const TYPE_QNAME = "0x3::token_event_store::OptInTransferEvent";

    const TYPE = new TypeDescriptor<OptInTransferEvent>(
      OptInTransferEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<OptInTransferEvent> {
      return TYPE.apply();
    }
  }

  export type OptInTransferEventInstance =
    TypedEventInstance<OptInTransferEvent> & {
      data_decoded: OptInTransferEvent;
      type_arguments: [];
    };

  export 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;
  }

  export namespace RoyaltyMutate {
    export const TYPE_QNAME = "0x3::token_event_store::RoyaltyMutate";

    const TYPE = new TypeDescriptor<RoyaltyMutate>(RoyaltyMutate.TYPE_QNAME);

    export function type(): TypeDescriptor<RoyaltyMutate> {
      return TYPE.apply();
    }
  }

  export type RoyaltyMutateInstance = TypedEventInstance<RoyaltyMutate> & {
    data_decoded: RoyaltyMutate;
    type_arguments: [];
  };

  export 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;
  }

  export namespace RoyaltyMutateEvent {
    export const TYPE_QNAME = "0x3::token_event_store::RoyaltyMutateEvent";

    const TYPE = new TypeDescriptor<RoyaltyMutateEvent>(
      RoyaltyMutateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RoyaltyMutateEvent> {
      return TYPE.apply();
    }
  }

  export type RoyaltyMutateEventInstance =
    TypedEventInstance<RoyaltyMutateEvent> & {
      data_decoded: RoyaltyMutateEvent;
      type_arguments: [];
    };

  export 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>;
  }

  export namespace TokenEventStoreV1 {
    export const TYPE_QNAME = "0x3::token_event_store::TokenEventStoreV1";

    const TYPE = new TypeDescriptor<TokenEventStoreV1>(
      TokenEventStoreV1.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TokenEventStoreV1> {
      return TYPE.apply();
    }
  }

  export interface UriMutation {
    creator: MoveAddressType;
    collection: string;
    token: string;
    old_uri: string;
    new_uri: string;
  }

  export namespace UriMutation {
    export const TYPE_QNAME = "0x3::token_event_store::UriMutation";

    const TYPE = new TypeDescriptor<UriMutation>(UriMutation.TYPE_QNAME);

    export function type(): TypeDescriptor<UriMutation> {
      return TYPE.apply();
    }
  }

  export type UriMutationInstance = TypedEventInstance<UriMutation> & {
    data_decoded: UriMutation;
    type_arguments: [];
  };

  export interface UriMutationEvent {
    creator: MoveAddressType;
    collection: string;
    token: string;
    old_uri: string;
    new_uri: string;
  }

  export namespace UriMutationEvent {
    export const TYPE_QNAME = "0x3::token_event_store::UriMutationEvent";

    const TYPE = new TypeDescriptor<UriMutationEvent>(
      UriMutationEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UriMutationEvent> {
      return TYPE.apply();
    }
  }

  export type UriMutationEventInstance =
    TypedEventInstance<UriMutationEvent> & {
      data_decoded: UriMutationEvent;
      type_arguments: [];
    };

  export namespace entry {}
  export namespace view {}
}

const MODULES = JSON.parse(
  '[{"abi":{"address":"0x3","name":"token","friends":[],"exposed_functions":[{"name":"merge","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x3::token::Token","0x3::token::Token"],"return":[]},{"name":"burn","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String","u64","u64"],"return":[]},{"name":"transfer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenId","address","u64"],"return":[]},{"name":"balance_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x3::token::TokenId"],"return":["u64"]},{"name":"burn_by_creator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String","u64","u64"],"return":[]},{"name":"check_collection_exists","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["bool"]},{"name":"check_tokendata_exists","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String","0x1::string::String"],"return":["bool"]},{"name":"create_collection","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String","u64","vector<bool>"],"return":[]},{"name":"create_collection_mutability_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<bool>"],"return":["0x3::token::CollectionMutabilityConfig"]},{"name":"create_collection_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String","u64","vector<bool>"],"return":[]},{"name":"create_royalty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64","address"],"return":["0x3::token::Royalty"]},{"name":"create_token_data_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String","0x1::string::String"],"return":["0x3::token::TokenDataId"]},{"name":"create_token_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenDataId","u64"],"return":["0x3::token::TokenId"]},{"name":"create_token_id_raw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String","0x1::string::String","u64"],"return":["0x3::token::TokenId"]},{"name":"create_token_mutability_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<bool>"],"return":["0x3::token::TokenMutabilityConfig"]},{"name":"create_token_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String","u64","u64","0x1::string::String","address","u64","u64","vector<bool>","vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":[]},{"name":"create_tokendata","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String","u64","0x1::string::String","address","u64","u64","0x3::token::TokenMutabilityConfig","vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":["0x3::token::TokenDataId"]},{"name":"create_withdraw_capability","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenId","u64","u64"],"return":["0x3::token::WithdrawCapability"]},{"name":"token_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::Token"],"return":["&0x3::token::TokenId"]},{"name":"deposit_token","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::Token"],"return":[]},{"name":"direct_deposit_with_opt_in","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x3::token::Token"],"return":[]},{"name":"direct_transfer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer","0x3::token::TokenId","u64"],"return":[]},{"name":"direct_transfer_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","&signer","address","0x1::string::String","0x1::string::String","u64","u64"],"return":[]},{"name":"get_collection_description","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["0x1::string::String"]},{"name":"get_collection_maximum","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["u64"]},{"name":"get_collection_mutability_config","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["0x3::token::CollectionMutabilityConfig"]},{"name":"get_collection_mutability_description","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::CollectionMutabilityConfig"],"return":["bool"]},{"name":"get_collection_mutability_maximum","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::CollectionMutabilityConfig"],"return":["bool"]},{"name":"get_collection_mutability_uri","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::CollectionMutabilityConfig"],"return":["bool"]},{"name":"get_collection_supply","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["0x1::option::Option<u64>"]},{"name":"get_collection_uri","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["0x1::string::String"]},{"name":"get_direct_transfer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"get_property_map","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x3::token::TokenId"],"return":["0x3::property_map::PropertyMap"]},{"name":"get_royalty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenId"],"return":["0x3::token::Royalty"]},{"name":"get_royalty_denominator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::Royalty"],"return":["u64"]},{"name":"get_royalty_numerator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::Royalty"],"return":["u64"]},{"name":"get_royalty_payee","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::Royalty"],"return":["address"]},{"name":"get_token_amount","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::Token"],"return":["u64"]},{"name":"get_token_data_id_fields","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenDataId"],"return":["address","0x1::string::String","0x1::string::String"]},{"name":"get_token_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::Token"],"return":["0x3::token::TokenId"]},{"name":"get_token_id_fields","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenId"],"return":["address","0x1::string::String","0x1::string::String","u64"]},{"name":"get_token_mutability_default_properties","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenMutabilityConfig"],"return":["bool"]},{"name":"get_token_mutability_description","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenMutabilityConfig"],"return":["bool"]},{"name":"get_token_mutability_maximum","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenMutabilityConfig"],"return":["bool"]},{"name":"get_token_mutability_royalty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenMutabilityConfig"],"return":["bool"]},{"name":"get_token_mutability_uri","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::token::TokenMutabilityConfig"],"return":["bool"]},{"name":"get_token_supply","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x3::token::TokenDataId"],"return":["0x1::option::Option<u64>"]},{"name":"get_tokendata_description","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenDataId"],"return":["0x1::string::String"]},{"name":"get_tokendata_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenId"],"return":["0x3::token::TokenDataId"]},{"name":"get_tokendata_largest_property_version","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x3::token::TokenDataId"],"return":["u64"]},{"name":"get_tokendata_maximum","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenDataId"],"return":["u64"]},{"name":"get_tokendata_mutability_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenDataId"],"return":["0x3::token::TokenMutabilityConfig"]},{"name":"get_tokendata_royalty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::TokenDataId"],"return":["0x3::token::Royalty"]},{"name":"get_tokendata_uri","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x3::token::TokenDataId"],"return":["0x1::string::String"]},{"name":"has_token_store","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"initialize_token","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenId"],"return":[]},{"name":"initialize_token_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize_token_store","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"mint_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String","u64"],"return":[]},{"name":"mint_token","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenDataId","u64"],"return":["0x3::token::TokenId"]},{"name":"mint_token_to","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x3::token::TokenDataId","u64"],"return":[]},{"name":"mutate_collection_description","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String"],"return":[]},{"name":"mutate_collection_maximum","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","u64"],"return":[]},{"name":"mutate_collection_uri","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String"],"return":[]},{"name":"mutate_one_token","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x3::token::TokenId","vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":["0x3::token::TokenId"]},{"name":"mutate_token_properties","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address","0x1::string::String","0x1::string::String","u64","u64","vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":[]},{"name":"mutate_tokendata_description","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenDataId","0x1::string::String"],"return":[]},{"name":"mutate_tokendata_maximum","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenDataId","u64"],"return":[]},{"name":"mutate_tokendata_property","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenDataId","vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":[]},{"name":"mutate_tokendata_royalty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenDataId","0x3::token::Royalty"],"return":[]},{"name":"mutate_tokendata_uri","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenDataId","0x1::string::String"],"return":[]},{"name":"opt_in_direct_transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"partial_withdraw_with_capability","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::WithdrawCapability","u64"],"return":["0x3::token::Token","0x1::option::Option<0x3::token::WithdrawCapability>"]},{"name":"split","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x3::token::Token","u64"],"return":["0x3::token::Token"]},{"name":"transfer_with_opt_in","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String","u64","address","u64"],"return":[]},{"name":"withdraw_token","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenId","u64"],"return":["0x3::token::Token"]},{"name":"withdraw_with_capability","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x3::token::WithdrawCapability"],"return":["0x3::token::Token"]}],"structs":[{"name":"Deposit","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"DepositEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"Withdraw","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"WithdrawEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"Burn","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"BurnToken","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"BurnTokenEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"CollectionData","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"description","type":"0x1::string::String"},{"name":"name","type":"0x1::string::String"},{"name":"uri","type":"0x1::string::String"},{"name":"supply","type":"u64"},{"name":"maximum","type":"u64"},{"name":"mutability_config","type":"0x3::token::CollectionMutabilityConfig"}],"variants":[]},{"name":"CollectionMutabilityConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"description","type":"bool"},{"name":"uri","type":"bool"},{"name":"maximum","type":"bool"}],"variants":[]},{"name":"Collections","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"collection_data","type":"0x1::table::Table<0x1::string::String, 0x3::token::CollectionData>"},{"name":"token_data","type":"0x1::table::Table<0x3::token::TokenDataId, 0x3::token::TokenData>"},{"name":"create_collection_events","type":"0x1::event::EventHandle<0x3::token::CreateCollectionEvent>"},{"name":"create_token_data_events","type":"0x1::event::EventHandle<0x3::token::CreateTokenDataEvent>"},{"name":"mint_token_events","type":"0x1::event::EventHandle<0x3::token::MintTokenEvent>"}],"variants":[]},{"name":"CreateCollection","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"uri","type":"0x1::string::String"},{"name":"description","type":"0x1::string::String"},{"name":"maximum","type":"u64"}],"variants":[]},{"name":"CreateCollectionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"uri","type":"0x1::string::String"},{"name":"description","type":"0x1::string::String"},{"name":"maximum","type":"u64"}],"variants":[]},{"name":"CreateTokenData","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenDataId"},{"name":"description","type":"0x1::string::String"},{"name":"maximum","type":"u64"},{"name":"uri","type":"0x1::string::String"},{"name":"royalty_payee_address","type":"address"},{"name":"royalty_points_denominator","type":"u64"},{"name":"royalty_points_numerator","type":"u64"},{"name":"name","type":"0x1::string::String"},{"name":"mutability_config","type":"0x3::token::TokenMutabilityConfig"},{"name":"property_keys","type":"vector<0x1::string::String>"},{"name":"property_values","type":"vector<vector<u8>>"},{"name":"property_types","type":"vector<0x1::string::String>"}],"variants":[]},{"name":"CreateTokenDataEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenDataId"},{"name":"description","type":"0x1::string::String"},{"name":"maximum","type":"u64"},{"name":"uri","type":"0x1::string::String"},{"name":"royalty_payee_address","type":"address"},{"name":"royalty_points_denominator","type":"u64"},{"name":"royalty_points_numerator","type":"u64"},{"name":"name","type":"0x1::string::String"},{"name":"mutability_config","type":"0x3::token::TokenMutabilityConfig"},{"name":"property_keys","type":"vector<0x1::string::String>"},{"name":"property_values","type":"vector<vector<u8>>"},{"name":"property_types","type":"vector<0x1::string::String>"}],"variants":[]},{"name":"Mint","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"id","type":"0x3::token::TokenDataId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"MintToken","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenDataId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"MintTokenEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenDataId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"MutatePropertyMap","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"old_id","type":"0x3::token::TokenId"},{"name":"new_id","type":"0x3::token::TokenId"},{"name":"keys","type":"vector<0x1::string::String>"},{"name":"values","type":"vector<vector<u8>>"},{"name":"types","type":"vector<0x1::string::String>"}],"variants":[]},{"name":"MutateTokenPropertyMap","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_id","type":"0x3::token::TokenId"},{"name":"new_id","type":"0x3::token::TokenId"},{"name":"keys","type":"vector<0x1::string::String>"},{"name":"values","type":"vector<vector<u8>>"},{"name":"types","type":"vector<0x1::string::String>"}],"variants":[]},{"name":"MutateTokenPropertyMapEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_id","type":"0x3::token::TokenId"},{"name":"new_id","type":"0x3::token::TokenId"},{"name":"keys","type":"vector<0x1::string::String>"},{"name":"values","type":"vector<vector<u8>>"},{"name":"types","type":"vector<0x1::string::String>"}],"variants":[]},{"name":"Royalty","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"royalty_points_numerator","type":"u64"},{"name":"royalty_points_denominator","type":"u64"},{"name":"payee_address","type":"address"}],"variants":[]},{"name":"Token","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"},{"name":"token_properties","type":"0x3::property_map::PropertyMap"}],"variants":[]},{"name":"TokenData","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"maximum","type":"u64"},{"name":"largest_property_version","type":"u64"},{"name":"supply","type":"u64"},{"name":"uri","type":"0x1::string::String"},{"name":"royalty","type":"0x3::token::Royalty"},{"name":"name","type":"0x1::string::String"},{"name":"description","type":"0x1::string::String"},{"name":"default_properties","type":"0x3::property_map::PropertyMap"},{"name":"mutability_config","type":"0x3::token::TokenMutabilityConfig"}],"variants":[]},{"name":"TokenDataCreation","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"id","type":"0x3::token::TokenDataId"},{"name":"description","type":"0x1::string::String"},{"name":"maximum","type":"u64"},{"name":"uri","type":"0x1::string::String"},{"name":"royalty_payee_address","type":"address"},{"name":"royalty_points_denominator","type":"u64"},{"name":"royalty_points_numerator","type":"u64"},{"name":"name","type":"0x1::string::String"},{"name":"mutability_config","type":"0x3::token::TokenMutabilityConfig"},{"name":"property_keys","type":"vector<0x1::string::String>"},{"name":"property_values","type":"vector<vector<u8>>"},{"name":"property_types","type":"vector<0x1::string::String>"}],"variants":[]},{"name":"TokenDataId","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"name","type":"0x1::string::String"}],"variants":[]},{"name":"TokenDeposit","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenId","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"token_data_id","type":"0x3::token::TokenDataId"},{"name":"property_version","type":"u64"}],"variants":[]},{"name":"TokenMutabilityConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"maximum","type":"bool"},{"name":"uri","type":"bool"},{"name":"royalty","type":"bool"},{"name":"description","type":"bool"},{"name":"properties","type":"bool"}],"variants":[]},{"name":"TokenStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"tokens","type":"0x1::table::Table<0x3::token::TokenId, 0x3::token::Token>"},{"name":"direct_transfer","type":"bool"},{"name":"deposit_events","type":"0x1::event::EventHandle<0x3::token::DepositEvent>"},{"name":"withdraw_events","type":"0x1::event::EventHandle<0x3::token::WithdrawEvent>"},{"name":"burn_events","type":"0x1::event::EventHandle<0x3::token::BurnTokenEvent>"},{"name":"mutate_token_property_events","type":"0x1::event::EventHandle<0x3::token::MutateTokenPropertyMapEvent>"}],"variants":[]},{"name":"TokenWithdraw","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"WithdrawCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"token_owner","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"},{"name":"expiration_sec","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x3","name":"property_map","friends":[],"exposed_functions":[{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x3::property_map::PropertyMap","&0x1::string::String"],"return":["0x1::string::String","0x3::property_map::PropertyValue"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":["0x3::property_map::PropertyMap"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["&0x3::property_map::PropertyValue"]},{"name":"empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x3::property_map::PropertyMap"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap"],"return":["u64"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x3::property_map::PropertyMap","0x1::string::String","0x3::property_map::PropertyValue"],"return":[]},{"name":"keys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap"],"return":["vector<0x1::string::String>"]},{"name":"values","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap"],"return":["vector<vector<u8>>"]},{"name":"contains_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["bool"]},{"name":"borrow_type","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyValue"],"return":["0x1::string::String"]},{"name":"borrow_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyValue"],"return":["vector<u8>"]},{"name":"create_property_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]}],"params":["&T0"],"return":["0x3::property_map::PropertyValue"]},{"name":"create_property_value_raw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","0x1::string::String"],"return":["0x3::property_map::PropertyValue"]},{"name":"types","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap"],"return":["vector<0x1::string::String>"]},{"name":"new_with_key_and_property_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::string::String>","vector<0x3::property_map::PropertyValue>"],"return":["0x3::property_map::PropertyMap"]},{"name":"read_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["address"]},{"name":"read_bool","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["bool"]},{"name":"read_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["0x1::string::String"]},{"name":"read_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["u128"]},{"name":"read_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["u64"]},{"name":"read_u8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x3::property_map::PropertyMap","&0x1::string::String"],"return":["u8"]},{"name":"update_property_map","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x3::property_map::PropertyMap","vector<0x1::string::String>","vector<vector<u8>>","vector<0x1::string::String>"],"return":[]},{"name":"update_property_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x3::property_map::PropertyMap","&0x1::string::String","0x3::property_map::PropertyValue"],"return":[]}],"structs":[{"name":"PropertyMap","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"map","type":"0x1::simple_map::SimpleMap<0x1::string::String, 0x3::property_map::PropertyValue>"}],"variants":[]},{"name":"PropertyValue","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"value","type":"vector<u8>"},{"name":"type","type":"0x1::string::String"}],"variants":[]}]}},{"abi":{"address":"0x3","name":"token_coin_swap","friends":[],"exposed_functions":[{"name":"cancel_token_listing","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","0x3::token::TokenId","u64"],"return":[]},{"name":"deposit_token_to_escrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenId","0x3::token::Token","u64"],"return":[]},{"name":"does_listing_exist","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","0x3::token::TokenId"],"return":["bool"]},{"name":"exchange_coin_for_token","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","u64","address","address","0x1::string::String","0x1::string::String","u64","u64"],"return":[]},{"name":"list_token_for_swap","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","address","0x1::string::String","0x1::string::String","u64","u64","u64","u64"],"return":[]},{"name":"withdraw_token_from_escrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x3::token::TokenId","u64"],"return":["0x3::token::Token"]}],"structs":[{"name":"TokenCoinSwap","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"token_amount","type":"u64"},{"name":"min_price_per_token","type":"u64"}],"variants":[]},{"name":"TokenEscrow","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"token","type":"0x3::token::Token"},{"name":"locked_until_secs","type":"u64"}],"variants":[]},{"name":"TokenListingEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"},{"name":"min_price","type":"u64"},{"name":"locked_until_secs","type":"u64"},{"name":"coin_type_info","type":"0x1::type_info::TypeInfo"}],"variants":[]},{"name":"TokenListings","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"listings","type":"0x1::table::Table<0x3::token::TokenId, 0x3::token_coin_swap::TokenCoinSwap<T0>>"},{"name":"listing_events","type":"0x1::event::EventHandle<0x3::token_coin_swap::TokenListingEvent>"},{"name":"swap_events","type":"0x1::event::EventHandle<0x3::token_coin_swap::TokenSwapEvent>"}],"variants":[]},{"name":"TokenStoreEscrow","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"token_escrows","type":"0x1::table::Table<0x3::token::TokenId, 0x3::token_coin_swap::TokenEscrow>"}],"variants":[]},{"name":"TokenSwapEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"token_id","type":"0x3::token::TokenId"},{"name":"token_buyer","type":"address"},{"name":"token_amount","type":"u64"},{"name":"coin_amount","type":"u64"},{"name":"coin_type_info","type":"0x1::type_info::TypeInfo"}],"variants":[]}]}},{"abi":{"address":"0x3","name":"token_transfers","friends":[],"exposed_functions":[{"name":"cancel_offer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x3::token::TokenId"],"return":[]},{"name":"cancel_offer_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["signer","address","address","0x1::string::String","0x1::string::String","u64"],"return":[]},{"name":"claim","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x3::token::TokenId"],"return":[]},{"name":"claim_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["signer","address","address","0x1::string::String","0x1::string::String","u64"],"return":[]},{"name":"offer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x3::token::TokenId","u64"],"return":[]},{"name":"offer_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["signer","address","address","0x1::string::String","0x1::string::String","u64","u64"],"return":[]}],"structs":[{"name":"CancelOffer","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"Claim","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"Offer","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"PendingClaims","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"pending_claims","type":"0x1::table::Table<0x3::token_transfers::TokenOfferId, 0x3::token::Token>"},{"name":"offer_events","type":"0x1::event::EventHandle<0x3::token_transfers::TokenOfferEvent>"},{"name":"cancel_offer_events","type":"0x1::event::EventHandle<0x3::token_transfers::TokenCancelOfferEvent>"},{"name":"claim_events","type":"0x1::event::EventHandle<0x3::token_transfers::TokenClaimEvent>"}],"variants":[]},{"name":"TokenCancelOffer","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenCancelOfferEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenClaim","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenClaimEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenOffer","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenOfferEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"to_address","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"TokenOfferId","is_native":false,"is_event":true,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"to_addr","type":"address"},{"name":"token_id","type":"0x3::token::TokenId"}],"variants":[]}]}},{"abi":{"address":"0x3","name":"token_event_store","friends":["0x3::token"],"exposed_functions":[{"name":"emit_collection_description_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String"],"return":[]},{"name":"emit_collection_maximum_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","u64","u64"],"return":[]},{"name":"emit_collection_uri_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String"],"return":[]},{"name":"emit_default_property_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","vector<0x1::string::String>","vector<0x1::option::Option<0x3::property_map::PropertyValue>>","vector<0x3::property_map::PropertyValue>"],"return":[]},{"name":"emit_token_descrition_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String","0x1::string::String"],"return":[]},{"name":"emit_token_maximum_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","u64","u64"],"return":[]},{"name":"emit_token_opt_in_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"emit_token_royalty_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","u64","u64","address","u64","u64","address"],"return":[]},{"name":"emit_token_uri_mutate_event","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String","0x1::string::String","0x1::string::String"],"return":[]}],"structs":[{"name":"CollectionDescriptionMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_description","type":"0x1::string::String"},{"name":"new_description","type":"0x1::string::String"}],"variants":[]},{"name":"CollectionDescriptionMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_description","type":"0x1::string::String"},{"name":"new_description","type":"0x1::string::String"}],"variants":[]},{"name":"CollectionMaximumMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_maximum","type":"u64"},{"name":"new_maximum","type":"u64"}],"variants":[]},{"name":"CollectionMaxiumMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_maximum","type":"u64"},{"name":"new_maximum","type":"u64"}],"variants":[]},{"name":"CollectionMaxiumMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_maximum","type":"u64"},{"name":"new_maximum","type":"u64"}],"variants":[]},{"name":"CollectionUriMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_uri","type":"0x1::string::String"},{"name":"new_uri","type":"0x1::string::String"}],"variants":[]},{"name":"CollectionUriMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator_addr","type":"address"},{"name":"collection_name","type":"0x1::string::String"},{"name":"old_uri","type":"0x1::string::String"},{"name":"new_uri","type":"0x1::string::String"}],"variants":[]},{"name":"DefaultPropertyMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"keys","type":"vector<0x1::string::String>"},{"name":"old_values","type":"vector<0x1::option::Option<0x3::property_map::PropertyValue>>"},{"name":"new_values","type":"vector<0x3::property_map::PropertyValue>"}],"variants":[]},{"name":"DefaultPropertyMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"keys","type":"vector<0x1::string::String>"},{"name":"old_values","type":"vector<0x1::option::Option<0x3::property_map::PropertyValue>>"},{"name":"new_values","type":"vector<0x3::property_map::PropertyValue>"}],"variants":[]},{"name":"DescriptionMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_description","type":"0x1::string::String"},{"name":"new_description","type":"0x1::string::String"}],"variants":[]},{"name":"DescriptionMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_description","type":"0x1::string::String"},{"name":"new_description","type":"0x1::string::String"}],"variants":[]},{"name":"MaximumMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_maximum","type":"u64"},{"name":"new_maximum","type":"u64"}],"variants":[]},{"name":"MaxiumMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_maximum","type":"u64"},{"name":"new_maximum","type":"u64"}],"variants":[]},{"name":"OptInTransfer","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account_address","type":"address"},{"name":"opt_in","type":"bool"}],"variants":[]},{"name":"OptInTransferEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"opt_in","type":"bool"}],"variants":[]},{"name":"RoyaltyMutate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_royalty_numerator","type":"u64"},{"name":"old_royalty_denominator","type":"u64"},{"name":"old_royalty_payee_addr","type":"address"},{"name":"new_royalty_numerator","type":"u64"},{"name":"new_royalty_denominator","type":"u64"},{"name":"new_royalty_payee_addr","type":"address"}],"variants":[]},{"name":"RoyaltyMutateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_royalty_numerator","type":"u64"},{"name":"old_royalty_denominator","type":"u64"},{"name":"old_royalty_payee_addr","type":"address"},{"name":"new_royalty_numerator","type":"u64"},{"name":"new_royalty_denominator","type":"u64"},{"name":"new_royalty_payee_addr","type":"address"}],"variants":[]},{"name":"TokenEventStoreV1","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"collection_uri_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::CollectionUriMutateEvent>"},{"name":"collection_maximum_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::CollectionMaxiumMutateEvent>"},{"name":"collection_description_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::CollectionDescriptionMutateEvent>"},{"name":"opt_in_events","type":"0x1::event::EventHandle<0x3::token_event_store::OptInTransferEvent>"},{"name":"uri_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::UriMutationEvent>"},{"name":"default_property_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::DefaultPropertyMutateEvent>"},{"name":"description_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::DescriptionMutateEvent>"},{"name":"royalty_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::RoyaltyMutateEvent>"},{"name":"maximum_mutate_events","type":"0x1::event::EventHandle<0x3::token_event_store::MaxiumMutateEvent>"},{"name":"extension","type":"0x1::option::Option<0x1::any::Any>"}],"variants":[]},{"name":"UriMutation","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_uri","type":"0x1::string::String"},{"name":"new_uri","type":"0x1::string::String"}],"variants":[]},{"name":"UriMutationEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"collection","type":"0x1::string::String"},{"name":"token","type":"0x1::string::String"},{"name":"old_uri","type":"0x1::string::String"},{"name":"new_uri","type":"0x1::string::String"}],"variants":[]}]}}]',
);

export function loadAllTypes(coder: MoveCoder) {
  _0x1.loadAllTypes(coder);
  for (const m of Object.values(MODULES)) {
    coder.load(m as any, "0x3");
  }
}

loadAllTypes(defaultMoveCoder(AptosNetwork.MAIN_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.TEST_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.MOVEMENT_MAIN_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.MOVEMENT_TEST_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.INITIA_ECHELON));