@sentio/sdk 2.4.0 → 2.5.0-rc.1

package/lib/sui/builtin/0x2.d.ts

@@ -0,0 +1,1047 @@
+import { CallFilter } from "@sentio/sdk/move";
+import { MoveCoder, SuiBindOptions, SuiBaseProcessor, TypedEventInstance, TypedEntryFunctionPayload, SuiContext } from "@sentio/sdk/sui";
+import { MoveFetchConfig } from "@sentio/protos";
+import { SuiAddress } from "@sentio/sdk/sui";
+import * as _0x1 from "./0x1.js";
+export declare namespace address { }
+export declare namespace bag {
+    class Bag {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        size: bigint;
+    }
+}
+export declare namespace balance {
+    class Balance<T0> {
+        static TYPE_QNAME: string;
+        value: bigint;
+    }
+    class Supply<T0> {
+        static TYPE_QNAME: string;
+        value: bigint;
+    }
+}
+export declare class bcs extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): bcs;
+    onEventBCS(func: (event: bcs.BCSInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): bcs;
+}
+export declare namespace bcs {
+    class BCS {
+        static TYPE_QNAME: string;
+        bytes: string;
+    }
+    interface BCSInstance extends TypedEventInstance<BCS> {
+        fields_decoded: BCS;
+        type_arguments: [];
+    }
+}
+export declare namespace bls12381 { }
+export declare namespace bulletproofs { }
+export declare class coin extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): coin;
+    onEntryBurn(func: (call: coin.BurnPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEntryJoin(func: (call: coin.JoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEntryMintAndTransfer(func: (call: coin.MintAndTransferPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEntryUpdateDescription(func: (call: coin.UpdateDescriptionPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEntryUpdateIconUrl(func: (call: coin.UpdateIconUrlPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEntryUpdateName(func: (call: coin.UpdateNamePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEntryUpdateSymbol(func: (call: coin.UpdateSymbolPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): coin;
+    onEventCurrencyCreated(func: (event: coin.CurrencyCreatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): coin;
+}
+export declare namespace coin {
+    class Coin<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        balance: balance.Balance<T0>;
+    }
+    class CoinMetadata<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        decimals: number;
+        name: string;
+        symbol: _0x1.ascii.String;
+        description: string;
+        icon_url: _0x1.option.Option<url.Url>;
+    }
+    class CurrencyCreated<T0> {
+        static TYPE_QNAME: string;
+        decimals: number;
+    }
+    interface CurrencyCreatedInstance extends TypedEventInstance<CurrencyCreated<any>> {
+        fields_decoded: CurrencyCreated<any>;
+        type_arguments: [string];
+    }
+    class TreasuryCap<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        total_supply: balance.Supply<T0>;
+    }
+    interface BurnPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface JoinPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface MintAndTransferPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, bigint, SuiAddress]> {
+        arguments_decoded: [SuiAddress, bigint, SuiAddress];
+        type_arguments: [string];
+    }
+    interface UpdateDescriptionPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [string];
+    }
+    interface UpdateIconUrlPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [string];
+    }
+    interface UpdateNamePayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [string];
+    }
+    interface UpdateSymbolPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [string];
+    }
+}
+export declare class devnet_nft extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): devnet_nft;
+    onEntryBurn(func: (call: devnet_nft.BurnPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): devnet_nft;
+    onEntryMint(func: (call: devnet_nft.MintPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): devnet_nft;
+    onEntryUpdateDescription(func: (call: devnet_nft.UpdateDescriptionPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): devnet_nft;
+    onEventMintNFTEvent(func: (event: devnet_nft.MintNFTEventInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): devnet_nft;
+}
+export declare namespace devnet_nft {
+    class DevNetNFT {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        name: string;
+        description: string;
+        url: url.Url;
+    }
+    class MintNFTEvent {
+        static TYPE_QNAME: string;
+        object_id: string;
+        creator: SuiAddress;
+        name: string;
+    }
+    interface MintNFTEventInstance extends TypedEventInstance<MintNFTEvent> {
+        fields_decoded: MintNFTEvent;
+        type_arguments: [];
+    }
+    interface BurnPayload extends TypedEntryFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface MintPayload extends TypedEntryFunctionPayload<[string, string, string]> {
+        arguments_decoded: [string, string, string];
+        type_arguments: [];
+    }
+    interface UpdateDescriptionPayload extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [];
+    }
+}
+export declare class digest extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): digest;
+    onEventSha3256Digest(func: (event: digest.Sha3256DigestInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): digest;
+}
+export declare namespace digest {
+    class Sha3256Digest {
+        static TYPE_QNAME: string;
+        digest: string;
+    }
+    interface Sha3256DigestInstance extends TypedEventInstance<Sha3256Digest> {
+        fields_decoded: Sha3256Digest;
+        type_arguments: [];
+    }
+}
+export declare namespace dynamic_field {
+    class Field<T0, T1> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        name: T0;
+        value: T1;
+    }
+}
+export declare class dynamic_object_field extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): dynamic_object_field;
+    onEventWrapper(func: (event: dynamic_object_field.WrapperInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): dynamic_object_field;
+}
+export declare namespace dynamic_object_field {
+    class Wrapper<T0> {
+        static TYPE_QNAME: string;
+        name: T0;
+    }
+    interface WrapperInstance extends TypedEventInstance<Wrapper<any>> {
+        fields_decoded: Wrapper<any>;
+        type_arguments: [string];
+    }
+}
+export declare namespace ecdsa_k1 { }
+export declare namespace ed25519 { }
+export declare class elliptic_curve extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): elliptic_curve;
+    onEventRistrettoPoint(func: (event: elliptic_curve.RistrettoPointInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): elliptic_curve;
+    onEventScalar(func: (event: elliptic_curve.ScalarInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): elliptic_curve;
+}
+export declare namespace elliptic_curve {
+    class RistrettoPoint {
+        static TYPE_QNAME: string;
+        value: string;
+    }
+    interface RistrettoPointInstance extends TypedEventInstance<RistrettoPoint> {
+        fields_decoded: RistrettoPoint;
+        type_arguments: [];
+    }
+    class Scalar {
+        static TYPE_QNAME: string;
+        value: string;
+    }
+    interface ScalarInstance extends TypedEventInstance<Scalar> {
+        fields_decoded: Scalar;
+        type_arguments: [];
+    }
+}
+export declare namespace epoch_time_lock {
+    class EpochTimeLock {
+        static TYPE_QNAME: string;
+        epoch: bigint;
+    }
+}
+export declare namespace erc721_metadata {
+    class ERC721Metadata {
+        static TYPE_QNAME: string;
+        token_id: erc721_metadata.TokenID;
+        name: string;
+        token_uri: url.Url;
+    }
+    class TokenID {
+        static TYPE_QNAME: string;
+        id: bigint;
+    }
+}
+export declare namespace event { }
+export declare namespace genesis { }
+export declare class groth16 extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): groth16;
+    onEventPreparedVerifyingKey(func: (event: groth16.PreparedVerifyingKeyInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
+    onEventProofPoints(func: (event: groth16.ProofPointsInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
+    onEventPublicProofInputs(func: (event: groth16.PublicProofInputsInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
+}
+export declare namespace groth16 {
+    class PreparedVerifyingKey {
+        static TYPE_QNAME: string;
+        vk_gamma_abc_g1_bytes: string;
+        alpha_g1_beta_g2_bytes: string;
+        gamma_g2_neg_pc_bytes: string;
+        delta_g2_neg_pc_bytes: string;
+    }
+    interface PreparedVerifyingKeyInstance extends TypedEventInstance<PreparedVerifyingKey> {
+        fields_decoded: PreparedVerifyingKey;
+        type_arguments: [];
+    }
+    class ProofPoints {
+        static TYPE_QNAME: string;
+        bytes: string;
+    }
+    interface ProofPointsInstance extends TypedEventInstance<ProofPoints> {
+        fields_decoded: ProofPoints;
+        type_arguments: [];
+    }
+    class PublicProofInputs {
+        static TYPE_QNAME: string;
+        bytes: string;
+    }
+    interface PublicProofInputsInstance extends TypedEventInstance<PublicProofInputs> {
+        fields_decoded: PublicProofInputs;
+        type_arguments: [];
+    }
+}
+export declare namespace hex { }
+export declare namespace hmac { }
+export declare class immutable_external_resource extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): immutable_external_resource;
+    onEventImmutableExternalResource(func: (event: immutable_external_resource.ImmutableExternalResourceInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): immutable_external_resource;
+}
+export declare namespace immutable_external_resource {
+    class ImmutableExternalResource {
+        static TYPE_QNAME: string;
+        url: url.Url;
+        digest: digest.Sha3256Digest;
+    }
+    interface ImmutableExternalResourceInstance extends TypedEventInstance<ImmutableExternalResource> {
+        fields_decoded: ImmutableExternalResource;
+        type_arguments: [];
+    }
+}
+export declare namespace linked_table {
+    class LinkedTable<T0, T1> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        size: bigint;
+        head: _0x1.option.Option<T0>;
+        tail: _0x1.option.Option<T0>;
+    }
+    class Node<T0, T1> {
+        static TYPE_QNAME: string;
+        prev: _0x1.option.Option<T0>;
+        next: _0x1.option.Option<T0>;
+        value: T1;
+    }
+}
+export declare class locked_coin extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): locked_coin;
+    onEntryLockCoin(func: (call: locked_coin.LockCoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): locked_coin;
+    onEntryUnlockCoin(func: (call: locked_coin.UnlockCoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): locked_coin;
+}
+export declare namespace locked_coin {
+    class LockedCoin<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        balance: balance.Balance<T0>;
+        locked_until_epoch: epoch_time_lock.EpochTimeLock;
+    }
+    interface LockCoinPayload<T0 = any> extends TypedEntryFunctionPayload<[string, SuiAddress, bigint]> {
+        arguments_decoded: [string, SuiAddress, bigint];
+        type_arguments: [string];
+    }
+    interface UnlockCoinPayload<T0 = any> extends TypedEntryFunctionPayload<[locked_coin.LockedCoin<T0>]> {
+        arguments_decoded: [locked_coin.LockedCoin<T0>];
+        type_arguments: [string];
+    }
+}
+export declare namespace math { }
+export declare class object_ extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): object_;
+    onEventID(func: (event: object_.IDInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): object_;
+}
+export declare namespace object_ {
+    class ID {
+        static TYPE_QNAME: string;
+        bytes: SuiAddress;
+    }
+    interface IDInstance extends TypedEventInstance<ID> {
+        fields_decoded: ID;
+        type_arguments: [];
+    }
+    class UID {
+        static TYPE_QNAME: string;
+        id: string;
+    }
+}
+export declare namespace object_bag {
+    class ObjectBag {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        size: bigint;
+    }
+}
+export declare namespace object_table {
+    class ObjectTable<T0, T1> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        size: bigint;
+    }
+}
+export declare class pay extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): pay;
+    onEntryDivideAndKeep(func: (call: pay.DivideAndKeepPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+    onEntryJoin(func: (call: pay.JoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+    onEntryJoinVec(func: (call: pay.JoinVecPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+    onEntryJoinVecAndTransfer(func: (call: pay.JoinVecAndTransferPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+    onEntrySplit(func: (call: pay.SplitPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+    onEntrySplitAndTransfer(func: (call: pay.SplitAndTransferPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+    onEntrySplitVec(func: (call: pay.SplitVecPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): pay;
+}
+export declare namespace pay {
+    interface DivideAndKeepPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, bigint];
+        type_arguments: [string];
+    }
+    interface JoinPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface JoinVecPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface JoinVecAndTransferPayload<T0 = any> extends TypedEntryFunctionPayload<[string[]]> {
+        arguments_decoded: [string[]];
+        type_arguments: [string];
+    }
+    interface SplitPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, bigint];
+        type_arguments: [string];
+    }
+    interface SplitAndTransferPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, bigint, SuiAddress]> {
+        arguments_decoded: [SuiAddress, bigint, SuiAddress];
+        type_arguments: [string];
+    }
+    interface SplitVecPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, bigint[]]> {
+        arguments_decoded: [SuiAddress, bigint[]];
+        type_arguments: [string];
+    }
+}
+export declare namespace priority_queue {
+    class Entry<T0> {
+        static TYPE_QNAME: string;
+        priority: bigint;
+        value: T0;
+    }
+    class PriorityQueue<T0> {
+        static TYPE_QNAME: string;
+        entries: priority_queue.Entry<T0>[];
+    }
+}
+export declare namespace publisher {
+    class Publisher {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        package: _0x1.ascii.String;
+        module_name: _0x1.ascii.String;
+    }
+}
+export declare class safe extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): safe;
+    onEntryCreate(func: (call: safe.CreatePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): safe;
+    onEntryCreateEmpty(func: (call: safe.CreateEmptyPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): safe;
+    onEntryDeposit(func: (call: safe.DepositPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): safe;
+    onEntryRevokeTransferCapability(func: (call: safe.RevokeTransferCapabilityPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): safe;
+    onEntrySelfRevokeTransferCapability(func: (call: safe.SelfRevokeTransferCapabilityPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): safe;
+    onEntryWithdraw(func: (call: safe.WithdrawPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): safe;
+}
+export declare namespace safe {
+    class OwnerCapability<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        safe_id: string;
+    }
+    class Safe<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        balance: balance.Balance<T0>;
+        allowed_safes: vec_set.VecSet<string>;
+    }
+    class TransferCapability<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        safe_id: string;
+        amount: bigint;
+    }
+    interface CreatePayload<T0 = any> extends TypedEntryFunctionPayload<[string]> {
+        arguments_decoded: [string];
+        type_arguments: [string];
+    }
+    interface CreateEmptyPayload<T0 = any> extends TypedEntryFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [string];
+    }
+    interface DepositPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface RevokeTransferCapabilityPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [string];
+    }
+    interface SelfRevokeTransferCapabilityPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface WithdrawPayload<T0 = any> extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, SuiAddress, bigint];
+        type_arguments: [string];
+    }
+}
+export declare class stake extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): stake;
+    onEntryBurn(func: (call: stake.BurnPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): stake;
+}
+export declare namespace stake {
+    class Stake {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        balance: balance.Balance<sui.SUI>;
+        locked_until_epoch: _0x1.option.Option<epoch_time_lock.EpochTimeLock>;
+    }
+    interface BurnPayload extends TypedEntryFunctionPayload<[stake.Stake]> {
+        arguments_decoded: [stake.Stake];
+        type_arguments: [];
+    }
+}
+export declare namespace stake_subsidy {
+    class StakeSubsidy {
+        static TYPE_QNAME: string;
+        epoch_counter: bigint;
+        balance: balance.Balance<sui.SUI>;
+        current_epoch_amount: bigint;
+    }
+}
+export declare class staking_pool extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): staking_pool;
+    onEntryDestroyEmptyDelegation(func: (call: staking_pool.DestroyEmptyDelegationPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_pool;
+    onEntryDestroyEmptyStakedSui(func: (call: staking_pool.DestroyEmptyStakedSuiPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_pool;
+    onEntryWithdrawFromInactivePool(func: (call: staking_pool.WithdrawFromInactivePoolPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): staking_pool;
+    onEventPoolTokenExchangeRate(func: (event: staking_pool.PoolTokenExchangeRateInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): staking_pool;
+}
+export declare namespace staking_pool {
+    class Delegation {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        staked_sui_id: string;
+        pool_tokens: balance.Balance<staking_pool.DelegationToken>;
+        principal_sui_amount: bigint;
+    }
+    class DelegationToken {
+        static TYPE_QNAME: string;
+        dummy_field: Boolean;
+    }
+    class InactiveStakingPool {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        pool: staking_pool.StakingPool;
+    }
+    class PendingDelegationEntry {
+        static TYPE_QNAME: string;
+        delegator: SuiAddress;
+        sui_amount: bigint;
+    }
+    class PendingWithdrawEntry {
+        static TYPE_QNAME: string;
+        delegator: SuiAddress;
+        principal_withdraw_amount: bigint;
+        withdrawn_pool_tokens: balance.Balance<staking_pool.DelegationToken>;
+    }
+    class PoolTokenExchangeRate {
+        static TYPE_QNAME: string;
+        sui_amount: bigint;
+        pool_token_amount: bigint;
+    }
+    interface PoolTokenExchangeRateInstance extends TypedEventInstance<PoolTokenExchangeRate> {
+        fields_decoded: PoolTokenExchangeRate;
+        type_arguments: [];
+    }
+    class StakedSui {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        validator_address: SuiAddress;
+        pool_starting_epoch: bigint;
+        delegation_request_epoch: bigint;
+        principal: balance.Balance<sui.SUI>;
+        sui_token_lock: _0x1.option.Option<epoch_time_lock.EpochTimeLock>;
+    }
+    class StakingPool {
+        static TYPE_QNAME: string;
+        validator_address: SuiAddress;
+        starting_epoch: bigint;
+        sui_balance: bigint;
+        rewards_pool: balance.Balance<sui.SUI>;
+        delegation_token_supply: balance.Supply<staking_pool.DelegationToken>;
+        pending_delegations: linked_table.LinkedTable<string, staking_pool.PendingDelegationEntry>;
+        pending_withdraws: table_vec.TableVec<staking_pool.PendingWithdrawEntry>;
+    }
+    interface DestroyEmptyDelegationPayload extends TypedEntryFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface DestroyEmptyStakedSuiPayload extends TypedEntryFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface WithdrawFromInactivePoolPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        staking_pool.StakedSui,
+        staking_pool.Delegation
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            staking_pool.StakedSui,
+            staking_pool.Delegation
+        ];
+        type_arguments: [];
+    }
+}
+export declare class sui extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): sui;
+    onEntryTransfer(func: (call: sui.TransferPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui;
+}
+export declare namespace sui {
+    class SUI {
+        static TYPE_QNAME: string;
+        dummy_field: Boolean;
+    }
+    interface TransferPayload extends TypedEntryFunctionPayload<[string]> {
+        arguments_decoded: [string];
+        type_arguments: [];
+    }
+}
+export declare class sui_system extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): sui_system;
+    onEntryAdvanceEpoch(func: (call: sui_system.AdvanceEpochPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryAdvanceEpochSafeMode(func: (call: sui_system.AdvanceEpochSafeModePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryCancelDelegationRequest(func: (call: sui_system.CancelDelegationRequestPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryReportValidator(func: (call: sui_system.ReportValidatorPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddDelegation(func: (call: sui_system.RequestAddDelegationPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddDelegationMulCoin(func: (call: sui_system.RequestAddDelegationMulCoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddDelegationMulLockedCoin(func: (call: sui_system.RequestAddDelegationMulLockedCoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddDelegationWithLockedCoin(func: (call: sui_system.RequestAddDelegationWithLockedCoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddStake(func: (call: sui_system.RequestAddStakePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddStakeWithLockedCoin(func: (call: sui_system.RequestAddStakeWithLockedCoinPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestAddValidator(func: (call: sui_system.RequestAddValidatorPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestRemoveValidator(func: (call: sui_system.RequestRemoveValidatorPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestSetCommissionRate(func: (call: sui_system.RequestSetCommissionRatePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestSetGasPrice(func: (call: sui_system.RequestSetGasPricePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestSwitchDelegation(func: (call: sui_system.RequestSwitchDelegationPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestWithdrawDelegation(func: (call: sui_system.RequestWithdrawDelegationPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryRequestWithdrawStake(func: (call: sui_system.RequestWithdrawStakePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEntryUndoReportValidator(func: (call: sui_system.UndoReportValidatorPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui_system;
+    onEventSystemEpochInfo(func: (event: sui_system.SystemEpochInfoInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): sui_system;
+}
+export declare namespace sui_system {
+    class SuiSystemState {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        epoch: bigint;
+        validators: validator_set.ValidatorSet;
+        sui_supply: balance.Supply<sui.SUI>;
+        storage_fund: balance.Balance<sui.SUI>;
+        parameters: sui_system.SystemParameters;
+        reference_gas_price: bigint;
+        validator_report_records: vec_map.VecMap<SuiAddress, vec_set.VecSet<SuiAddress>>;
+        stake_subsidy: stake_subsidy.StakeSubsidy;
+        safe_mode: Boolean;
+    }
+    class SystemEpochInfo {
+        static TYPE_QNAME: string;
+        epoch: bigint;
+        reference_gas_price: bigint;
+        total_stake: bigint;
+        storage_fund_inflows: bigint;
+        storage_fund_outflows: bigint;
+        storage_fund_balance: bigint;
+        stake_subsidy_amount: bigint;
+        total_gas_fees: bigint;
+        total_stake_rewards: bigint;
+    }
+    interface SystemEpochInfoInstance extends TypedEventInstance<SystemEpochInfo> {
+        fields_decoded: SystemEpochInfo;
+        type_arguments: [];
+    }
+    class SystemParameters {
+        static TYPE_QNAME: string;
+        min_validator_stake: bigint;
+        max_validator_candidate_count: bigint;
+        storage_gas_price: bigint;
+    }
+    interface AdvanceEpochPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        bigint,
+        bigint,
+        bigint,
+        bigint,
+        bigint,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint,
+            bigint
+        ];
+        type_arguments: [];
+    }
+    interface AdvanceEpochSafeModePayload extends TypedEntryFunctionPayload<[SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, bigint];
+        type_arguments: [];
+    }
+    interface CancelDelegationRequestPayload extends TypedEntryFunctionPayload<[SuiAddress, staking_pool.StakedSui]> {
+        arguments_decoded: [SuiAddress, staking_pool.StakedSui];
+        type_arguments: [];
+    }
+    interface ReportValidatorPayload extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [];
+    }
+    interface RequestAddDelegationPayload extends TypedEntryFunctionPayload<[SuiAddress, string, SuiAddress]> {
+        arguments_decoded: [SuiAddress, string, SuiAddress];
+        type_arguments: [];
+    }
+    interface RequestAddDelegationMulCoinPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        string[],
+        _0x1.option.Option<bigint>,
+        SuiAddress
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            string[],
+            _0x1.option.Option<bigint>,
+            SuiAddress
+        ];
+        type_arguments: [];
+    }
+    interface RequestAddDelegationMulLockedCoinPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        locked_coin.LockedCoin<sui.SUI>[],
+        _0x1.option.Option<bigint>,
+        SuiAddress
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            locked_coin.LockedCoin<sui.SUI>[],
+            _0x1.option.Option<bigint>,
+            SuiAddress
+        ];
+        type_arguments: [];
+    }
+    interface RequestAddDelegationWithLockedCoinPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        locked_coin.LockedCoin<sui.SUI>,
+        SuiAddress
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            locked_coin.LockedCoin<sui.SUI>,
+            SuiAddress
+        ];
+        type_arguments: [];
+    }
+    interface RequestAddStakePayload extends TypedEntryFunctionPayload<[SuiAddress, string]> {
+        arguments_decoded: [SuiAddress, string];
+        type_arguments: [];
+    }
+    interface RequestAddStakeWithLockedCoinPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        locked_coin.LockedCoin<sui.SUI>
+    ]> {
+        arguments_decoded: [SuiAddress, locked_coin.LockedCoin<sui.SUI>];
+        type_arguments: [];
+    }
+    interface RequestAddValidatorPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            string,
+            bigint,
+            bigint
+        ];
+        type_arguments: [];
+    }
+    interface RequestRemoveValidatorPayload extends TypedEntryFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [];
+    }
+    interface RequestSetCommissionRatePayload extends TypedEntryFunctionPayload<[SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, bigint];
+        type_arguments: [];
+    }
+    interface RequestSetGasPricePayload extends TypedEntryFunctionPayload<[SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, bigint];
+        type_arguments: [];
+    }
+    interface RequestSwitchDelegationPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        staking_pool.Delegation,
+        staking_pool.StakedSui,
+        SuiAddress
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            staking_pool.Delegation,
+            staking_pool.StakedSui,
+            SuiAddress
+        ];
+        type_arguments: [];
+    }
+    interface RequestWithdrawDelegationPayload extends TypedEntryFunctionPayload<[
+        SuiAddress,
+        staking_pool.Delegation,
+        staking_pool.StakedSui
+    ]> {
+        arguments_decoded: [
+            SuiAddress,
+            staking_pool.Delegation,
+            staking_pool.StakedSui
+        ];
+        type_arguments: [];
+    }
+    interface RequestWithdrawStakePayload extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress, bigint]> {
+        arguments_decoded: [SuiAddress, SuiAddress, bigint];
+        type_arguments: [];
+    }
+    interface UndoReportValidatorPayload extends TypedEntryFunctionPayload<[SuiAddress, SuiAddress]> {
+        arguments_decoded: [SuiAddress, SuiAddress];
+        type_arguments: [];
+    }
+}
+export declare namespace table {
+    class Table<T0, T1> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        size: bigint;
+    }
+}
+export declare namespace table_vec {
+    class TableVec<T0> {
+        static TYPE_QNAME: string;
+        contents: table.Table<bigint, T0>;
+    }
+}
+export declare namespace transfer { }
+export declare namespace tx_context {
+    class TxContext {
+        static TYPE_QNAME: string;
+        sender: SuiAddress;
+        tx_hash: string;
+        epoch: bigint;
+        ids_created: bigint;
+    }
+}
+export declare class typed_id extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): typed_id;
+    onEventTypedID(func: (event: typed_id.TypedIDInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): typed_id;
+}
+export declare namespace typed_id {
+    class TypedID<T0> {
+        static TYPE_QNAME: string;
+        id: string;
+    }
+    interface TypedIDInstance extends TypedEventInstance<TypedID<any>> {
+        fields_decoded: TypedID<any>;
+        type_arguments: [string];
+    }
+}
+export declare namespace types { }
+export declare class url extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): url;
+    onEventUrl(func: (event: url.UrlInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): url;
+}
+export declare namespace url {
+    class Url {
+        static TYPE_QNAME: string;
+        url: _0x1.ascii.String;
+    }
+    interface UrlInstance extends TypedEventInstance<Url> {
+        fields_decoded: Url;
+        type_arguments: [];
+    }
+}
+export declare class validator extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): validator;
+    onEventValidatorMetadata(func: (event: validator.ValidatorMetadataInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): validator;
+}
+export declare namespace validator {
+    class Validator {
+        static TYPE_QNAME: string;
+        metadata: validator.ValidatorMetadata;
+        voting_power: bigint;
+        stake_amount: bigint;
+        pending_stake: bigint;
+        pending_withdraw: bigint;
+        gas_price: bigint;
+        delegation_staking_pool: staking_pool.StakingPool;
+        commission_rate: bigint;
+    }
+    class ValidatorMetadata {
+        static TYPE_QNAME: string;
+        sui_address: SuiAddress;
+        pubkey_bytes: string;
+        network_pubkey_bytes: string;
+        worker_pubkey_bytes: string;
+        proof_of_possession: string;
+        name: string;
+        description: string;
+        image_url: url.Url;
+        project_url: url.Url;
+        net_address: string;
+        consensus_address: string;
+        worker_address: string;
+        next_epoch_stake: bigint;
+        next_epoch_delegation: bigint;
+        next_epoch_gas_price: bigint;
+        next_epoch_commission_rate: bigint;
+    }
+    interface ValidatorMetadataInstance extends TypedEventInstance<ValidatorMetadata> {
+        fields_decoded: ValidatorMetadata;
+        type_arguments: [];
+    }
+}
+export declare class validator_set extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): validator_set;
+    onEventDelegationRequestEvent(func: (event: validator_set.DelegationRequestEventInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): validator_set;
+    onEventValidatorEpochInfo(func: (event: validator_set.ValidatorEpochInfoInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): validator_set;
+    onEventValidatorPair(func: (event: validator_set.ValidatorPairInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): validator_set;
+}
+export declare namespace validator_set {
+    class DelegationRequestEvent {
+        static TYPE_QNAME: string;
+        validator_address: SuiAddress;
+        delegator_address: SuiAddress;
+        epoch: bigint;
+        amount: bigint;
+    }
+    interface DelegationRequestEventInstance extends TypedEventInstance<DelegationRequestEvent> {
+        fields_decoded: DelegationRequestEvent;
+        type_arguments: [];
+    }
+    class ValidatorEpochInfo {
+        static TYPE_QNAME: string;
+        epoch: bigint;
+        validator_address: SuiAddress;
+        reference_gas_survey_quote: bigint;
+        validator_stake: bigint;
+        delegated_stake: bigint;
+        commission_rate: bigint;
+        stake_rewards: bigint;
+        pool_token_exchange_rate: staking_pool.PoolTokenExchangeRate;
+        tallying_rule_reporters: SuiAddress[];
+        tallying_rule_global_score: bigint;
+    }
+    interface ValidatorEpochInfoInstance extends TypedEventInstance<ValidatorEpochInfo> {
+        fields_decoded: ValidatorEpochInfo;
+        type_arguments: [];
+    }
+    class ValidatorPair {
+        static TYPE_QNAME: string;
+        from: SuiAddress;
+        to: SuiAddress;
+    }
+    interface ValidatorPairInstance extends TypedEventInstance<ValidatorPair> {
+        fields_decoded: ValidatorPair;
+        type_arguments: [];
+    }
+    class ValidatorSet {
+        static TYPE_QNAME: string;
+        total_validator_stake: bigint;
+        total_delegation_stake: bigint;
+        active_validators: validator.Validator[];
+        pending_validators: validator.Validator[];
+        pending_removals: bigint[];
+        next_epoch_validators: validator.ValidatorMetadata[];
+        pending_delegation_switches: vec_map.VecMap<validator_set.ValidatorPair, table_vec.TableVec<staking_pool.PendingWithdrawEntry>>;
+    }
+}
+export declare class vec_map extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): vec_map;
+    onEventEntry(func: (event: vec_map.EntryInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): vec_map;
+    onEventVecMap(func: (event: vec_map.VecMapInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): vec_map;
+}
+export declare namespace vec_map {
+    class Entry<T0, T1> {
+        static TYPE_QNAME: string;
+        key: T0;
+        value: T1;
+    }
+    interface EntryInstance extends TypedEventInstance<Entry<any, any>> {
+        fields_decoded: Entry<any, any>;
+        type_arguments: [string, string];
+    }
+    class VecMap<T0, T1> {
+        static TYPE_QNAME: string;
+        contents: vec_map.Entry<T0, T1>[];
+    }
+    interface VecMapInstance extends TypedEventInstance<VecMap<any, any>> {
+        fields_decoded: VecMap<any, any>;
+        type_arguments: [string, string];
+    }
+}
+export declare class vec_set extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): vec_set;
+    onEventVecSet(func: (event: vec_set.VecSetInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): vec_set;
+}
+export declare namespace vec_set {
+    class VecSet<T0> {
+        static TYPE_QNAME: string;
+        contents: T0[] | string;
+    }
+    interface VecSetInstance extends TypedEventInstance<VecSet<any>> {
+        fields_decoded: VecSet<any>;
+        type_arguments: [string];
+    }
+}
+export declare namespace voting_power {
+    class VotingPowerInfo {
+        static TYPE_QNAME: string;
+        validator_index: bigint;
+        voting_power: bigint;
+    }
+}
+export declare function loadAllTypes(coder: MoveCoder): void;