@sentio/sdk 2.10.2 → 2.11.0-rc.2

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

@@ -38,7 +38,25 @@ export declare namespace bcs {
     }
 }
 export declare namespace bls12381 { }
-export declare namespace bulletproofs { }
+export declare namespace borrow {
+    class Borrow {
+        static TYPE_QNAME: string;
+        ref: SuiAddress;
+        obj: object_.ID;
+    }
+    class Referent<T0> {
+        static TYPE_QNAME: string;
+        id: SuiAddress;
+        value: _0x1.option.Option<T0>;
+    }
+}
+export declare namespace clock {
+    class Clock {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        timestamp_ms: bigint;
+    }
+}
 export declare class coin extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
@@ -105,60 +123,67 @@ export declare namespace coin {
         type_arguments: [string];
     }
 }
-export declare class devnet_nft extends SuiBaseProcessor {
+export declare class display 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 bind(options?: Partial<SuiBindOptions>): display;
+    onEntryAdd(func: (call: display.AddPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): display;
+    onEntryAddMultiple(func: (call: display.AddMultiplePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): display;
+    onEntryCreateAndKeep(func: (call: display.CreateAndKeepPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): display;
+    onEntryEdit(func: (call: display.EditPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): display;
+    onEntryRemove(func: (call: display.RemovePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): display;
+    onEntryUpdateVersion(func: (call: display.UpdateVersionPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): display;
+    onEventDisplayCreated(func: (event: display.DisplayCreatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): display;
+    onEventVersionUpdated(func: (event: display.VersionUpdatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): display;
+}
+export declare namespace display {
+    class Display<T0> {
         static TYPE_QNAME: string;
         id: object_.UID;
-        name: string;
-        description: string;
-        url: url.Url;
+        fields: vec_map.VecMap<string, string>;
+        version: number;
     }
-    class MintNFTEvent {
+    class DisplayCreated<T0> {
         static TYPE_QNAME: string;
-        object_id: object_.ID;
-        creator: SuiAddress;
-        name: string;
+        id: object_.ID;
     }
-    interface MintNFTEventInstance extends TypedEventInstance<MintNFTEvent> {
-        fields_decoded: MintNFTEvent;
-        type_arguments: [];
+    interface DisplayCreatedInstance extends TypedEventInstance<DisplayCreated<any>> {
+        fields_decoded: DisplayCreated<any>;
+        type_arguments: [string];
     }
-    interface BurnPayload extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
-        type_arguments: [];
+    class VersionUpdated<T0> {
+        static TYPE_QNAME: string;
+        id: object_.ID;
+        version: number;
+        fields: vec_map.VecMap<string, string>;
     }
-    interface MintPayload extends TypedFunctionPayload<[number[], number[], number[]]> {
-        arguments_decoded: [number[], number[], number[]];
-        type_arguments: [];
+    interface VersionUpdatedInstance extends TypedEventInstance<VersionUpdated<any>> {
+        fields_decoded: VersionUpdated<any>;
+        type_arguments: [string];
+    }
+    interface AddPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress, string]> {
+        arguments_decoded: [SuiAddress, string];
+        type_arguments: [string];
+    }
+    interface AddMultiplePayload<T0 = any> extends TypedFunctionPayload<[SuiAddress, string[]]> {
+        arguments_decoded: [SuiAddress, string[]];
+        type_arguments: [string];
     }
-    interface UpdateDescriptionPayload extends TypedFunctionPayload<[SuiAddress]> {
+    interface CreateAndKeepPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress]> {
         arguments_decoded: [SuiAddress];
-        type_arguments: [];
+        type_arguments: [string];
     }
-}
-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: number[];
+    interface EditPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress, string]> {
+        arguments_decoded: [SuiAddress, string];
+        type_arguments: [string];
     }
-    interface Sha3256DigestInstance extends TypedEventInstance<Sha3256Digest> {
-        fields_decoded: Sha3256Digest;
-        type_arguments: [];
+    interface RemovePayload<T0 = any> extends TypedFunctionPayload<[SuiAddress]> {
+        arguments_decoded: [SuiAddress];
+        type_arguments: [string];
+    }
+    interface UpdateVersionPayload<T0 = any> extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [string];
     }
 }
 export declare namespace dynamic_field {
@@ -186,61 +211,28 @@ export declare namespace dynamic_object_field {
     }
 }
 export declare namespace ecdsa_k1 { }
+export declare namespace ecdsa_r1 { }
+export declare namespace ecvrf { }
 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: number[];
-    }
-    interface RistrettoPointInstance extends TypedEventInstance<RistrettoPoint> {
-        fields_decoded: RistrettoPoint;
-        type_arguments: [];
-    }
-    class Scalar {
-        static TYPE_QNAME: string;
-        value: number[];
-    }
-    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;
+    onEventCurve(func: (event: groth16.CurveInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): 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 Curve {
+        static TYPE_QNAME: string;
+        id: number;
+    }
+    interface CurveInstance extends TypedEventInstance<Curve> {
+        fields_decoded: Curve;
+        type_arguments: [];
+    }
     class PreparedVerifyingKey {
         static TYPE_QNAME: string;
         vk_gamma_abc_g1_bytes: number[];
@@ -269,24 +261,74 @@ export declare namespace groth16 {
         type_arguments: [];
     }
 }
+export declare namespace hash { }
 export declare namespace hex { }
 export declare namespace hmac { }
-export declare class immutable_external_resource extends SuiBaseProcessor {
+export declare class kiosk 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;
+    static bind(options?: Partial<SuiBindOptions>): kiosk;
+    onEventItem(func: (event: kiosk.ItemInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
+    onEventItemListed(func: (event: kiosk.ItemListedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
+    onEventListing(func: (event: kiosk.ListingInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
+    onEventLock(func: (event: kiosk.LockInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
 }
-export declare namespace immutable_external_resource {
-    class ImmutableExternalResource {
+export declare namespace kiosk {
+    class Item {
         static TYPE_QNAME: string;
-        url: url.Url;
-        digest: digest.Sha3256Digest;
+        id: object_.ID;
     }
-    interface ImmutableExternalResourceInstance extends TypedEventInstance<ImmutableExternalResource> {
-        fields_decoded: ImmutableExternalResource;
+    interface ItemInstance extends TypedEventInstance<Item> {
+        fields_decoded: Item;
         type_arguments: [];
     }
+    class ItemListed<T0> {
+        static TYPE_QNAME: string;
+        kiosk: object_.ID;
+        id: object_.ID;
+        price: bigint;
+    }
+    interface ItemListedInstance extends TypedEventInstance<ItemListed<any>> {
+        fields_decoded: ItemListed<any>;
+        type_arguments: [string];
+    }
+    class Kiosk {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        profits: balance.Balance<sui.SUI>;
+        owner: SuiAddress;
+        item_count: number;
+        allow_extensions: Boolean;
+    }
+    class KioskOwnerCap {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        for: object_.ID;
+    }
+    class Listing {
+        static TYPE_QNAME: string;
+        id: object_.ID;
+        is_exclusive: Boolean;
+    }
+    interface ListingInstance extends TypedEventInstance<Listing> {
+        fields_decoded: Listing;
+        type_arguments: [];
+    }
+    class Lock {
+        static TYPE_QNAME: string;
+        id: object_.ID;
+    }
+    interface LockInstance extends TypedEventInstance<Lock> {
+        fields_decoded: Lock;
+        type_arguments: [];
+    }
+    class PurchaseCap<T0> {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        kiosk_id: object_.ID;
+        item_id: object_.ID;
+        min_price: bigint;
+    }
 }
 export declare namespace linked_table {
     class LinkedTable<T0, T1> {
@@ -303,29 +345,6 @@ export declare namespace linked_table {
         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 TypedFunctionPayload<[coin.Coin<T0>, SuiAddress, bigint]> {
-        arguments_decoded: [coin.Coin<T0>, SuiAddress, bigint];
-        type_arguments: [string];
-    }
-    interface UnlockCoinPayload<T0 = any> extends TypedFunctionPayload<[locked_coin.LockedCoin<T0>]> {
-        arguments_decoded: [locked_coin.LockedCoin<T0>];
-        type_arguments: [string];
-    }
-}
 export declare namespace math { }
 export declare namespace object_ {
     type ID = string;
@@ -348,6 +367,53 @@ export declare namespace object_table {
         size: bigint;
     }
 }
+export declare class package_ extends SuiBaseProcessor {
+    constructor(options: SuiBindOptions);
+    static DEFAULT_OPTIONS: SuiBindOptions;
+    static bind(options?: Partial<SuiBindOptions>): package_;
+    onEntryMakeImmutable(func: (call: package_.MakeImmutablePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): package_;
+    onEntryOnlyAdditiveUpgrades(func: (call: package_.OnlyAdditiveUpgradesPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): package_;
+    onEntryOnlyDepUpgrades(func: (call: package_.OnlyDepUpgradesPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): package_;
+}
+export declare namespace package_ {
+    class Publisher {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        package: _0x1.ascii.String;
+        module_name: _0x1.ascii.String;
+    }
+    class UpgradeCap {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        package: object_.ID;
+        version: bigint;
+        policy: number;
+    }
+    class UpgradeReceipt {
+        static TYPE_QNAME: string;
+        cap: object_.ID;
+        package: object_.ID;
+    }
+    class UpgradeTicket {
+        static TYPE_QNAME: string;
+        cap: object_.ID;
+        package: object_.ID;
+        policy: number;
+        digest: number[];
+    }
+    interface MakeImmutablePayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface OnlyAdditiveUpgradesPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface OnlyDepUpgradesPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+}
 export declare class pay extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
@@ -401,467 +467,90 @@ export declare namespace priority_queue {
         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 {
+export declare namespace prover { }
+export declare class sui 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;
+    static bind(options?: Partial<SuiBindOptions>): sui;
+    onEntryTransfer(func: (call: sui.TransferPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: MoveFetchConfig): sui;
 }
-export declare namespace safe {
-    class OwnerCapability<T0> {
-        static TYPE_QNAME: string;
-        id: object_.UID;
-        safe_id: object_.ID;
-    }
-    class Safe<T0> {
-        static TYPE_QNAME: string;
-        id: object_.UID;
-        balance: balance.Balance<T0>;
-        allowed_safes: vec_set.VecSet<object_.ID>;
-    }
-    class TransferCapability<T0> {
+export declare namespace sui {
+    class SUI {
         static TYPE_QNAME: string;
-        id: object_.UID;
-        safe_id: object_.ID;
-        amount: bigint;
-    }
-    interface CreatePayload<T0 = any> extends TypedFunctionPayload<[coin.Coin<T0>]> {
-        arguments_decoded: [coin.Coin<T0>];
-        type_arguments: [string];
-    }
-    interface CreateEmptyPayload<T0 = any> extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
-        type_arguments: [string];
-    }
-    interface DepositPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress]> {
-        arguments_decoded: [SuiAddress];
-        type_arguments: [string];
-    }
-    interface RevokeTransferCapabilityPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress, SuiAddress]> {
-        arguments_decoded: [SuiAddress, SuiAddress];
-        type_arguments: [string];
-    }
-    interface SelfRevokeTransferCapabilityPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress]> {
-        arguments_decoded: [SuiAddress];
-        type_arguments: [string];
+        dummy_field: Boolean;
     }
-    interface WithdrawPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress, SuiAddress, bigint]> {
-        arguments_decoded: [SuiAddress, SuiAddress, bigint];
-        type_arguments: [string];
+    interface TransferPayload extends TypedFunctionPayload<[coin.Coin<sui.SUI>]> {
+        arguments_decoded: [coin.Coin<sui.SUI>];
+        type_arguments: [];
     }
 }
-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 {
+export declare namespace table {
+    class Table<T0, T1> {
         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 TypedFunctionPayload<[stake.Stake]> {
-        arguments_decoded: [stake.Stake];
-        type_arguments: [];
+        size: bigint;
     }
 }
-export declare namespace stake_subsidy {
-    class StakeSubsidy {
+export declare namespace table_vec {
+    class TableVec<T0> {
         static TYPE_QNAME: string;
-        epoch_counter: bigint;
-        balance: balance.Balance<sui.SUI>;
-        current_epoch_amount: bigint;
+        contents: table.Table<bigint, T0>;
     }
 }
-export declare class staking_pool extends SuiBaseProcessor {
+export declare namespace transfer { }
+export declare class transfer_policy 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;
+    static bind(options?: Partial<SuiBindOptions>): transfer_policy;
+    onEventRuleKey(func: (event: transfer_policy.RuleKeyInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): transfer_policy;
+    onEventTransferPolicyCreated(func: (event: transfer_policy.TransferPolicyCreatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): transfer_policy;
 }
-export declare namespace staking_pool {
-    class Delegation {
-        static TYPE_QNAME: string;
-        id: object_.UID;
-        staked_sui_id: object_.ID;
-        pool_tokens: balance.Balance<staking_pool.DelegationToken>;
-        principal_sui_amount: bigint;
-    }
-    class DelegationToken {
+export declare namespace transfer_policy {
+    class RuleKey<T0> {
         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: [];
+    interface RuleKeyInstance extends TypedEventInstance<RuleKey<any>> {
+        fields_decoded: RuleKey<any>;
+        type_arguments: [string];
     }
-    class StakedSui {
+    class TransferPolicy<T0> {
         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<object_.ID, staking_pool.PendingDelegationEntry>;
-        pending_withdraws: table_vec.TableVec<staking_pool.PendingWithdrawEntry>;
-    }
-    interface DestroyEmptyDelegationPayload extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
-        type_arguments: [];
-    }
-    interface DestroyEmptyStakedSuiPayload extends TypedFunctionPayload<[]> {
-        arguments_decoded: [];
-        type_arguments: [];
-    }
-    interface WithdrawFromInactivePoolPayload extends TypedFunctionPayload<[
-        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 TypedFunctionPayload<[coin.Coin<sui.SUI>]> {
-        arguments_decoded: [coin.Coin<sui.SUI>];
-        type_arguments: [];
+        balance: balance.Balance<sui.SUI>;
+        rules: vec_set.VecSet<_0x1.type_name.TypeName>;
     }
-}
-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 {
+    class TransferPolicyCap<T0> {
         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: [];
+        policy_id: object_.ID;
     }
-    class SystemParameters {
+    class TransferPolicyCreated<T0> {
         static TYPE_QNAME: string;
-        min_validator_stake: bigint;
-        max_validator_candidate_count: bigint;
-        storage_gas_price: bigint;
-    }
-    interface AdvanceEpochPayload extends TypedFunctionPayload<[
-        SuiAddress,
-        bigint,
-        bigint,
-        bigint,
-        bigint,
-        bigint,
-        bigint,
-        bigint
-    ]> {
-        arguments_decoded: [
-            SuiAddress,
-            bigint,
-            bigint,
-            bigint,
-            bigint,
-            bigint,
-            bigint,
-            bigint
-        ];
-        type_arguments: [];
-    }
-    interface AdvanceEpochSafeModePayload extends TypedFunctionPayload<[SuiAddress, bigint]> {
-        arguments_decoded: [SuiAddress, bigint];
-        type_arguments: [];
-    }
-    interface CancelDelegationRequestPayload extends TypedFunctionPayload<[SuiAddress, staking_pool.StakedSui]> {
-        arguments_decoded: [SuiAddress, staking_pool.StakedSui];
-        type_arguments: [];
-    }
-    interface ReportValidatorPayload extends TypedFunctionPayload<[SuiAddress, SuiAddress]> {
-        arguments_decoded: [SuiAddress, SuiAddress];
-        type_arguments: [];
-    }
-    interface RequestAddDelegationPayload extends TypedFunctionPayload<[SuiAddress, coin.Coin<sui.SUI>, SuiAddress]> {
-        arguments_decoded: [SuiAddress, coin.Coin<sui.SUI>, SuiAddress];
-        type_arguments: [];
-    }
-    interface RequestAddDelegationMulCoinPayload extends TypedFunctionPayload<[
-        SuiAddress,
-        coin.Coin<sui.SUI>[],
-        _0x1.option.Option<bigint>,
-        SuiAddress
-    ]> {
-        arguments_decoded: [
-            SuiAddress,
-            coin.Coin<sui.SUI>[],
-            _0x1.option.Option<bigint>,
-            SuiAddress
-        ];
-        type_arguments: [];
-    }
-    interface RequestAddDelegationMulLockedCoinPayload extends TypedFunctionPayload<[
-        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 TypedFunctionPayload<[
-        SuiAddress,
-        locked_coin.LockedCoin<sui.SUI>,
-        SuiAddress
-    ]> {
-        arguments_decoded: [
-            SuiAddress,
-            locked_coin.LockedCoin<sui.SUI>,
-            SuiAddress
-        ];
-        type_arguments: [];
-    }
-    interface RequestAddStakePayload extends TypedFunctionPayload<[SuiAddress, coin.Coin<sui.SUI>]> {
-        arguments_decoded: [SuiAddress, coin.Coin<sui.SUI>];
-        type_arguments: [];
-    }
-    interface RequestAddStakeWithLockedCoinPayload extends TypedFunctionPayload<[
-        SuiAddress,
-        locked_coin.LockedCoin<sui.SUI>
-    ]> {
-        arguments_decoded: [SuiAddress, locked_coin.LockedCoin<sui.SUI>];
-        type_arguments: [];
-    }
-    interface RequestAddValidatorPayload extends TypedFunctionPayload<[
-        SuiAddress,
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        number[],
-        coin.Coin<sui.SUI>,
-        bigint,
-        bigint
-    ]> {
-        arguments_decoded: [
-            SuiAddress,
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            number[],
-            coin.Coin<sui.SUI>,
-            bigint,
-            bigint
-        ];
-        type_arguments: [];
-    }
-    interface RequestRemoveValidatorPayload extends TypedFunctionPayload<[SuiAddress]> {
-        arguments_decoded: [SuiAddress];
-        type_arguments: [];
-    }
-    interface RequestSetCommissionRatePayload extends TypedFunctionPayload<[SuiAddress, bigint]> {
-        arguments_decoded: [SuiAddress, bigint];
-        type_arguments: [];
-    }
-    interface RequestSetGasPricePayload extends TypedFunctionPayload<[SuiAddress, bigint]> {
-        arguments_decoded: [SuiAddress, bigint];
-        type_arguments: [];
-    }
-    interface RequestSwitchDelegationPayload extends TypedFunctionPayload<[
-        SuiAddress,
-        staking_pool.Delegation,
-        staking_pool.StakedSui,
-        SuiAddress
-    ]> {
-        arguments_decoded: [
-            SuiAddress,
-            staking_pool.Delegation,
-            staking_pool.StakedSui,
-            SuiAddress
-        ];
-        type_arguments: [];
-    }
-    interface RequestWithdrawDelegationPayload extends TypedFunctionPayload<[
-        SuiAddress,
-        staking_pool.Delegation,
-        staking_pool.StakedSui
-    ]> {
-        arguments_decoded: [
-            SuiAddress,
-            staking_pool.Delegation,
-            staking_pool.StakedSui
-        ];
-        type_arguments: [];
-    }
-    interface RequestWithdrawStakePayload extends TypedFunctionPayload<[SuiAddress, SuiAddress, bigint]> {
-        arguments_decoded: [SuiAddress, SuiAddress, bigint];
-        type_arguments: [];
-    }
-    interface UndoReportValidatorPayload extends TypedFunctionPayload<[SuiAddress, SuiAddress]> {
-        arguments_decoded: [SuiAddress, SuiAddress];
-        type_arguments: [];
+        id: object_.ID;
     }
-}
-export declare namespace table {
-    class Table<T0, T1> {
-        static TYPE_QNAME: string;
-        id: object_.UID;
-        size: bigint;
+    interface TransferPolicyCreatedInstance extends TypedEventInstance<TransferPolicyCreated<any>> {
+        fields_decoded: TransferPolicyCreated<any>;
+        type_arguments: [string];
     }
-}
-export declare namespace table_vec {
-    class TableVec<T0> {
+    class TransferRequest<T0> {
         static TYPE_QNAME: string;
-        contents: table.Table<bigint, T0>;
+        item: object_.ID;
+        paid: bigint;
+        from: object_.ID;
+        receipts: vec_set.VecSet<_0x1.type_name.TypeName>;
     }
 }
-export declare namespace transfer { }
 export declare namespace tx_context {
     class TxContext {
         static TYPE_QNAME: string;
         sender: SuiAddress;
         tx_hash: number[];
         epoch: bigint;
+        epoch_timestamp_ms: 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: object_.ID;
-    }
-    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);
@@ -879,105 +568,6 @@ export declare namespace 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: number[];
-        network_pubkey_bytes: number[];
-        worker_pubkey_bytes: number[];
-        proof_of_possession: number[];
-        name: string;
-        description: string;
-        image_url: url.Url;
-        project_url: url.Url;
-        net_address: number[];
-        consensus_address: number[];
-        worker_address: number[];
-        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;
@@ -1020,11 +610,16 @@ export declare namespace vec_set {
         type_arguments: [string];
     }
 }
-export declare namespace voting_power {
-    class VotingPowerInfo {
+export declare namespace versioned {
+    class VersionChangeCap {
         static TYPE_QNAME: string;
-        validator_index: bigint;
-        voting_power: bigint;
+        versioned_id: object_.ID;
+        old_version: bigint;
+    }
+    class Versioned {
+        static TYPE_QNAME: string;
+        id: object_.UID;
+        version: bigint;
     }
 }
 export declare function loadAllTypes(coder: MoveCoder): void;