@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/waterx_prediction/waterx_prediction.d.ts

@@ -0,0 +1,1858 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const MarketRegistry: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** One shared settlement pool for all markets using coin type `T`. */
+    balance: MoveStruct<{
+        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    /** Exact market lookup: external market id bytes -> linked-table key. */
+    market_id_map: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    unresolved_markets: MoveStruct<any, any>;
+    resolved_markets: MoveStruct<any, any>;
+    /** Set of market keys where new opens are blocked. Presence = paused. */
+    paused_markets: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    /** Pending open and close orders waiting for broker/keeper execution. */
+    orders: MoveStruct<any, any>;
+    /** Filled positions with active Polymarket exposure. */
+    positions: MoveStruct<any, any>;
+    /**
+     * Filled order id -> filled position id. Split positions are independent positions
+     * and are not indexed here.
+     */
+    position_id_by_order: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    /**
+     * Reverse index for cleaning `position_id_by_order` when the filled position is
+     * claimed or closed.
+     */
+    order_id_by_position: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    next_order_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    next_position_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    next_market_key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Minimum time after order placement before user self-cancel is allowed. */
+    order_cancel_cooldown_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** Floor balance that `admin_withdraw` must respect. */
+    min_reserve: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/prediction::waterx_prediction::MarketRegistry<phantom T>">;
+export declare const Market: MoveStruct<any, any>;
+export declare const MarketPointer: MoveStruct<{
+    key: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    resolved: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@waterx/prediction::waterx_prediction::MarketPointer">;
+export declare const PriceSettlement: MoveStruct<{
+    /** Oracle ticker to read, e.g. "BTCUSD". */
+    settle_ticker: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    /**
+     * Exact snapshot timestamp to read (must already be registered on-chain via
+     * `oracle::register_price_at_timestamp`).
+     */
+    settle_timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    /** 1e9-scaled `Float` raw value the price is compared against. */
+    threshold: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    /** One of CMP_GT / CMP_GTE / CMP_LT / CMP_LTE. */
+    comparison: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+}, "@waterx/prediction::waterx_prediction::PriceSettlement">;
+export declare const PriceSettlementKey: MoveStruct<{
+    market_id: import("@mysten/sui/bcs").BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/prediction::waterx_prediction::PriceSettlementKey">;
+export interface CreateMarketRegistryArguments {
+    _: RawTransactionArgument<string>;
+}
+export interface CreateMarketRegistryOptions {
+    package?: string;
+    arguments: CreateMarketRegistryArguments | [
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin-only: spin up the shared market registry object for coin type `T`. All
+ * markets for this coin type should settle through this object.
+ */
+export declare function createMarketRegistry(options: CreateMarketRegistryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PlaceOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    receiverAccountId: RawTransactionArgument<string>;
+    maxSpend: RawTransactionArgument<number | bigint>;
+    marketId: RawTransactionArgument<Array<number>>;
+    selection: TransactionArgument;
+    minShares: RawTransactionArgument<number | bigint>;
+    priceCap: RawTransactionArgument<number | bigint>;
+    expiryTs: RawTransactionArgument<number | bigint>;
+}
+export interface PlaceOrderOptions {
+    package?: string;
+    arguments: PlaceOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        receiverAccountId: RawTransactionArgument<string>,
+        maxSpend: RawTransactionArgument<number | bigint>,
+        marketId: RawTransactionArgument<Array<number>>,
+        selection: TransactionArgument,
+        minShares: RawTransactionArgument<number | bigint>,
+        priceCap: RawTransactionArgument<number | bigint>,
+        expiryTs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed variant: debits `max_spend` from `account_id` in
+ * `waterx_account`, records pending-order/refunds against that payer, and gives
+ * the filled position to `receiver_account_id`.
+ */
+export declare function placeOrder(options: PlaceOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelfCancelOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface SelfCancelOrderOptions {
+    package?: string;
+    arguments: SelfCancelOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed rescue for a stuck open order. Refunds go back into the
+ * waterx_account stored balance.
+ */
+export declare function selfCancelOrder(options: SelfCancelOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ClaimArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface ClaimOptions {
+    package?: string;
+    arguments: ClaimArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Account-backed claim. Payout is credited to the owning waterx_account balance. */
+export declare function claim(options: ClaimOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestCloseArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    minProceeds: RawTransactionArgument<number | bigint>;
+    expiryTs: RawTransactionArgument<number | bigint>;
+}
+export interface RequestCloseOptions {
+    package?: string;
+    arguments: RequestCloseArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        minProceeds: RawTransactionArgument<number | bigint>,
+        expiryTs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed close request. Auth is checked against the owning waterx_account.
+ * The position is locked in PendingClose until a keeper confirms the sell, a
+ * keeper cancels it, or the user self-cancels past `self_cancel_after_ts`. Aborts
+ * if the market has already resolved.
+ */
+export declare function requestClose(options: RequestCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestPartialCloseArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    closeShares: RawTransactionArgument<number | bigint>;
+    minProceeds: RawTransactionArgument<number | bigint>;
+    expiryTs: RawTransactionArgument<number | bigint>;
+}
+export interface RequestPartialCloseOptions {
+    package?: string;
+    arguments: RequestPartialCloseArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        closeShares: RawTransactionArgument<number | bigint>,
+        minProceeds: RawTransactionArgument<number | bigint>,
+        expiryTs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed partial close. Splits `close_shares` off `position_id` into a new
+ * same-account position and runs the close flow on it; the remainder stays `Open`
+ * under `position_id`. Auth `PERM_REQUEST_CLOSE` — value stays in the account, so
+ * unlike `split_position` it is not transfer-equivalent. Emits a dedicated
+ * `PartialCloseRequested` plus `PositionSplit` (from == to) and `CloseRequested`
+ * for the new position. Returns the new PendingClose position id.
+ */
+export declare function requestPartialClose(options: RequestPartialCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SelfCancelCloseArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface SelfCancelCloseOptions {
+    package?: string;
+    arguments: SelfCancelCloseArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Account-backed PendingClose rescue. Reverts the position to Open. */
+export declare function selfCancelClose(options: SelfCancelCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TransferPositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    recipientAccountId: RawTransactionArgument<string>;
+}
+export interface TransferPositionOptions {
+    package?: string;
+    arguments: TransferPositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        recipientAccountId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed position transfer. The source account owner moves an open
+ * prediction position to another WXA account; future close/claim proceeds go to
+ * the recipient account.
+ */
+export declare function transferPosition(options: TransferPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SplitPositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    recipientAccountId: RawTransactionArgument<string>;
+    splitShares: RawTransactionArgument<number | bigint>;
+}
+export interface SplitPositionOptions {
+    package?: string;
+    arguments: SplitPositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        recipientAccountId: RawTransactionArgument<string>,
+        splitShares: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-backed partial transfer. Splits an open position into two normal
+ * positions: the source keeps the remainder and the recipient receives a new
+ * independent position with proportional cost basis.
+ */
+export declare function splitPosition(options: SplitPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AdminPlaceOrderForArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    payment: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+    selection: TransactionArgument;
+    minShares: RawTransactionArgument<number | bigint>;
+    priceCap: RawTransactionArgument<number | bigint>;
+    expiryTs: RawTransactionArgument<number | bigint>;
+}
+export interface AdminPlaceOrderForOptions {
+    package?: string;
+    arguments: AdminPlaceOrderForArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        payment: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>,
+        selection: TransactionArgument,
+        minShares: RawTransactionArgument<number | bigint>,
+        priceCap: RawTransactionArgument<number | bigint>,
+        expiryTs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin-funded account position. The admin supplies the payment coin, while future
+ * user exits and admin refunds/claims return value to `account_id` in
+ * `waterx_account`.
+ */
+export declare function adminPlaceOrderFor(options: AdminPlaceOrderForOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FillOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    filledShares: RawTransactionArgument<number | bigint>;
+    filledCost: RawTransactionArgument<number | bigint>;
+}
+export interface FillOrderOptions {
+    package?: string;
+    arguments: FillOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        filledShares: RawTransactionArgument<number | bigint>,
+        filledCost: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper reports the Polymarket fill back to chain. Account-backed fill
+ * confirmation. Any unspent max_spend is credited back to the payer account, then
+ * a new independent position id is allocated.
+ */
+export declare function fillOrder(options: FillOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CancelOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface CancelOrderOptions {
+    package?: string;
+    arguments: CancelOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper-initiated cancel. Used when Polymarket couldn't fill at all.
+ * Account-backed keeper cancel. Full refund is credited to the owning
+ * waterx_account.
+ */
+export declare function cancelOrder(options: CancelOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ConfirmCloseArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    proceeds: RawTransactionArgument<number | bigint>;
+}
+export interface ConfirmCloseOptions {
+    package?: string;
+    arguments: ConfirmCloseArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        proceeds: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper reports the Polymarket sell back to chain. Pays user `proceeds` and
+ * closes the position. Aborts if `proceeds < close_min_proceeds`. Account-backed
+ * close confirmation. Proceeds are credited to the owning waterx_account.
+ */
+export declare function confirmClose(options: ConfirmCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CancelCloseArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface CancelCloseOptions {
+    package?: string;
+    arguments: CancelCloseArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper-initiated cancel of a PendingClose request. Used when the
+ * waterx_prediction couldn't sell on Polymarket. Reverts position to Open — shares
+ * are intact.
+ */
+export declare function cancelClose(options: CancelCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ForceClaimArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface ForceClaimOptions {
+    package?: string;
+    arguments: ForceClaimArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper settles a position for the owning waterx_account. Same payout math as
+ * `claim`; keeper just pays the gas.
+ *
+ * Two main use cases:
+ *
+ * 1.  **Batch payout distribution** — after `resolve_market`, chain multiple
+ *     `force_claim` calls in one PTB to settle every position on that market in a
+ *     single tx. Users get paid without spending gas.
+ * 2.  **Zombie cleanup** - losing-side positions where payout = 0 give the account
+ *     no incentive to call `claim`. Force-claim removes the position while leaving
+ *     market metadata available for indexed queries.
+ *
+ * Only operates on open positions. Pending open orders and pending close orders
+ * have their own resolution paths (`fill_order` / `confirm_close`). Account-backed
+ * keeper claim. Used for gas-sponsored settlement and zombie cleanup when the
+ * position belongs to a waterx_account.
+ */
+export declare function forceClaim(options: ForceClaimOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositSettlementArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    payment: RawTransactionArgument<string>;
+}
+export interface DepositSettlementOptions {
+    package?: string;
+    arguments: DepositSettlementArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        payment: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositSettlement(options: DepositSettlementOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AdminWithdrawArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    amount: RawTransactionArgument<number | bigint>;
+    recipient: RawTransactionArgument<string>;
+}
+export interface AdminWithdrawOptions {
+    package?: string;
+    arguments: AdminWithdrawArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        amount: RawTransactionArgument<number | bigint>,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin pulls capital out of the market_registry — used to realise
+ * waterx_prediction spread/profit or rebalance working capital. Aborts if the
+ * post-balance would dip below `min_reserve`, providing a kill-switch against
+ * accidental drains.
+ */
+export declare function adminWithdraw(options: AdminWithdrawOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetMinReserveArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    newReserve: RawTransactionArgument<number | bigint>;
+}
+export interface SetMinReserveOptions {
+    package?: string;
+    arguments: SetMinReserveArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        newReserve: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin sets the minimum reserve floor. Future `admin_withdraw` calls abort if
+ * they would leave `market_registry.balance` below this. Does NOT block user
+ * payouts — `claim` and refunds bypass `min_reserve` entirely (those are user
+ * funds).
+ */
+export declare function setMinReserve(options: SetMinReserveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetOrderCancelCooldownMsArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    newCooldownMs: RawTransactionArgument<number | bigint>;
+}
+export interface SetOrderCancelCooldownMsOptions {
+    package?: string;
+    arguments: SetOrderCancelCooldownMsArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        newCooldownMs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin sets the minimum account-owner self-cancel cooldown for newly created open
+ * and close orders. Existing orders keep their stored self-cancel time.
+ */
+export declare function setOrderCancelCooldownMs(options: SetOrderCancelCooldownMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolveMarketArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+    outcome: TransactionArgument;
+}
+export interface ResolveMarketOptions {
+    package?: string;
+    arguments: ResolveMarketArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>,
+        outcome: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Keeper records the market outcome. Aborts if already resolved. */
+export declare function resolveMarket(options: ResolveMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetPriceSettlementArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+    settleTicker: RawTransactionArgument<string>;
+    settleTimestampMs: RawTransactionArgument<number | bigint>;
+    threshold: RawTransactionArgument<number | bigint>;
+    comparison: RawTransactionArgument<number>;
+}
+export interface SetPriceSettlementOptions {
+    package?: string;
+    arguments: SetPriceSettlementArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>,
+        settleTicker: RawTransactionArgument<string>,
+        settleTimestampMs: RawTransactionArgument<number | bigint>,
+        threshold: RawTransactionArgument<number | bigint>,
+        comparison: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin pre-commits the price-settlement config for a market. Stored as a dynamic
+ * field on the registry; re-calling overwrites (until resolved).
+ */
+export declare function setPriceSettlement(options: SetPriceSettlementOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolveWithOracleArguments {
+    globalConfig: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    marketRegistry: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface ResolveWithOracleOptions {
+    package?: string;
+    arguments: ResolveWithOracleArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        marketRegistry: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Keeper resolves a price-settled market from an on-chain oracle snapshot. The
+ * price at `settle_timestamp_ms` must already be registered on the oracle (the
+ * keeper PTB submits `waterx_rule::quote_for_timestamp` →
+ * `oracle::register_price_at_timestamp` before calling this). The outcome is
+ * derived from the pre-committed threshold + comparison, so the keeper cannot
+ * influence the result beyond triggering it. Aborts if no settlement is set or the
+ * market is already resolved.
+ */
+export declare function resolveWithOracle(options: ResolveWithOracleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PauseMarketArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface PauseMarketOptions {
+    package?: string;
+    arguments: PauseMarketArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin pauses new opens for a specific market. Existing positions unaffected. If
+ * the market does not exist yet, this creates market metadata and emits
+ * `MarketCreated { by_admin: true }` before `MarketPaused`.
+ */
+export declare function pauseMarket(options: PauseMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnpauseMarketArguments {
+    _: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface UnpauseMarketOptions {
+    package?: string;
+    arguments: UnpauseMarketArguments | [
+        _: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Admin re-enables opens for a previously paused market. */
+export declare function unpauseMarket(options: UnpauseMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionStatusArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionStatusOptions {
+    package?: string;
+    arguments: PositionStatusArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionStatus(options: PositionStatusOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionAccountIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionAccountIdOptions {
+    package?: string;
+    arguments: PositionAccountIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionAccountId(options: PositionAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionMarketIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionMarketIdOptions {
+    package?: string;
+    arguments: PositionMarketIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionMarketId(options: PositionMarketIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionSelectionArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionSelectionOptions {
+    package?: string;
+    arguments: PositionSelectionArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionSelection(options: PositionSelectionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionPayoutArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionPayoutOptions {
+    package?: string;
+    arguments: PositionPayoutArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionPayout(options: PositionPayoutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionFilledArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionFilledOptions {
+    package?: string;
+    arguments: PositionFilledArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionFilled(options: PositionFilledOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionOpenedTsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionOpenedTsOptions {
+    package?: string;
+    arguments: PositionOpenedTsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionOpenedTs(options: PositionOpenedTsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionCloseExpiryArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionCloseExpiryOptions {
+    package?: string;
+    arguments: PositionCloseExpiryArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionCloseExpiry(options: PositionCloseExpiryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionCloseOrderIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionCloseOrderIdOptions {
+    package?: string;
+    arguments: PositionCloseOrderIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionCloseOrderId(options: PositionCloseOrderIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionCloseSelfCancelAfterTsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionCloseSelfCancelAfterTsOptions {
+    package?: string;
+    arguments: PositionCloseSelfCancelAfterTsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionCloseSelfCancelAfterTs(options: PositionCloseSelfCancelAfterTsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionCloseMinProceedsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionCloseMinProceedsOptions {
+    package?: string;
+    arguments: PositionCloseMinProceedsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionCloseMinProceeds(options: PositionCloseMinProceedsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionExistsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionExistsOptions {
+    package?: string;
+    arguments: PositionExistsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionExists(options: PositionExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketRegistryBalanceArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface MarketRegistryBalanceOptions {
+    package?: string;
+    arguments: MarketRegistryBalanceArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketRegistryBalance(options: MarketRegistryBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketRegistryMinReserveArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface MarketRegistryMinReserveOptions {
+    package?: string;
+    arguments: MarketRegistryMinReserveArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketRegistryMinReserve(options: MarketRegistryMinReserveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketRegistryOrderCancelCooldownMsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface MarketRegistryOrderCancelCooldownMsOptions {
+    package?: string;
+    arguments: MarketRegistryOrderCancelCooldownMsArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketRegistryOrderCancelCooldownMs(options: MarketRegistryOrderCancelCooldownMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NextOrderIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface NextOrderIdOptions {
+    package?: string;
+    arguments: NextOrderIdArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function nextOrderId(options: NextOrderIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NextPositionIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface NextPositionIdOptions {
+    package?: string;
+    arguments: NextPositionIdArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function nextPositionId(options: NextPositionIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionIdForOrderArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionIdForOrderOptions {
+    package?: string;
+    arguments: PositionIdForOrderArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionIdForOrder(options: PositionIdForOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsMarketResolvedArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface IsMarketResolvedOptions {
+    package?: string;
+    arguments: IsMarketResolvedArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isMarketResolved(options: IsMarketResolvedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsMarketPausedArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface IsMarketPausedOptions {
+    package?: string;
+    arguments: IsMarketPausedArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isMarketPaused(options: IsMarketPausedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsMarketPausedByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface IsMarketPausedByKeyOptions {
+    package?: string;
+    arguments: IsMarketPausedByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isMarketPausedByKey(options: IsMarketPausedByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketExistsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface MarketExistsOptions {
+    package?: string;
+    arguments: MarketExistsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketExists(options: MarketExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketOutcomeArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface MarketOutcomeOptions {
+    package?: string;
+    arguments: MarketOutcomeArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Aborts if the market is unresolved or doesn't exist. */
+export declare function marketOutcome(options: MarketOutcomeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketOutcomeByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface MarketOutcomeByKeyOptions {
+    package?: string;
+    arguments: MarketOutcomeByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketOutcomeByKey(options: MarketOutcomeByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketUnclaimedCountArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface MarketUnclaimedCountOptions {
+    package?: string;
+    arguments: MarketUnclaimedCountArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketUnclaimedCount(options: MarketUnclaimedCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketExposureArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface MarketExposureOptions {
+    package?: string;
+    arguments: MarketExposureArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketExposure(options: MarketExposureOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrdersArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface OrdersOptions {
+    package?: string;
+    arguments: OrdersArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orders(options: OrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderCountArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface OrderCountOptions {
+    package?: string;
+    arguments: OrderCountArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderCount(options: OrderCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderKeyAtArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    index: RawTransactionArgument<number | bigint>;
+}
+export interface OrderKeyAtOptions {
+    package?: string;
+    arguments: OrderKeyAtArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        index: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderKeyAt(options: OrderKeyAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderFrontArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface OrderFrontOptions {
+    package?: string;
+    arguments: OrderFrontArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderFront(options: OrderFrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderBackArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface OrderBackOptions {
+    package?: string;
+    arguments: OrderBackArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderBack(options: OrderBackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderNextArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderNextOptions {
+    package?: string;
+    arguments: OrderNextArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderNext(options: OrderNextOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderPrevArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderPrevOptions {
+    package?: string;
+    arguments: OrderPrevArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderPrev(options: OrderPrevOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderExistsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderExistsOptions {
+    package?: string;
+    arguments: OrderExistsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderExists(options: OrderExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    lookupOrderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderIdOptions {
+    package?: string;
+    arguments: OrderIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        lookupOrderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderId(options: OrderIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderKindArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderKindOptions {
+    package?: string;
+    arguments: OrderKindArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderKind(options: OrderKindOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderAccountIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderAccountIdOptions {
+    package?: string;
+    arguments: OrderAccountIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderAccountId(options: OrderAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderReceiverAccountIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderReceiverAccountIdOptions {
+    package?: string;
+    arguments: OrderReceiverAccountIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderReceiverAccountId(options: OrderReceiverAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderMarketIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderMarketIdOptions {
+    package?: string;
+    arguments: OrderMarketIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderMarketId(options: OrderMarketIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderSelectionArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderSelectionOptions {
+    package?: string;
+    arguments: OrderSelectionArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderSelection(options: OrderSelectionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderPositionIdArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderPositionIdOptions {
+    package?: string;
+    arguments: OrderPositionIdArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderPositionId(options: OrderPositionIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderMaxSpendArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderMaxSpendOptions {
+    package?: string;
+    arguments: OrderMaxSpendArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderMaxSpend(options: OrderMaxSpendOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderMinSharesArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderMinSharesOptions {
+    package?: string;
+    arguments: OrderMinSharesArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderMinShares(options: OrderMinSharesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderPriceCapArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderPriceCapOptions {
+    package?: string;
+    arguments: OrderPriceCapArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderPriceCap(options: OrderPriceCapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderMinProceedsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderMinProceedsOptions {
+    package?: string;
+    arguments: OrderMinProceedsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderMinProceeds(options: OrderMinProceedsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderExpiryArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderExpiryOptions {
+    package?: string;
+    arguments: OrderExpiryArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderExpiry(options: OrderExpiryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderSelfCancelAfterTsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderSelfCancelAfterTsOptions {
+    package?: string;
+    arguments: OrderSelfCancelAfterTsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderSelfCancelAfterTs(options: OrderSelfCancelAfterTsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderCreatedTsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderCreatedTsOptions {
+    package?: string;
+    arguments: OrderCreatedTsArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderCreatedTs(options: OrderCreatedTsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderIsByAdminArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface OrderIsByAdminOptions {
+    package?: string;
+    arguments: OrderIsByAdminArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function orderIsByAdmin(options: OrderIsByAdminOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface PositionsOptions {
+    package?: string;
+    arguments: PositionsArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positions(options: PositionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionCountArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface PositionCountOptions {
+    package?: string;
+    arguments: PositionCountArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionCount(options: PositionCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionKeyAtArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    index: RawTransactionArgument<number | bigint>;
+}
+export interface PositionKeyAtOptions {
+    package?: string;
+    arguments: PositionKeyAtArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        index: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionKeyAt(options: PositionKeyAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionFrontArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface PositionFrontOptions {
+    package?: string;
+    arguments: PositionFrontArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionFront(options: PositionFrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionBackArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface PositionBackOptions {
+    package?: string;
+    arguments: PositionBackArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionBack(options: PositionBackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionNextArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionNextOptions {
+    package?: string;
+    arguments: PositionNextArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionNext(options: PositionNextOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PositionPrevArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface PositionPrevOptions {
+    package?: string;
+    arguments: PositionPrevArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function positionPrev(options: PositionPrevOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketCountArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface MarketCountOptions {
+    package?: string;
+    arguments: MarketCountArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketCount(options: MarketCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<Array<number>>;
+}
+export interface MarketKeyOptions {
+    package?: string;
+    arguments: MarketKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketKey(options: MarketKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketKeyAtArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    index: RawTransactionArgument<number | bigint>;
+}
+export interface MarketKeyAtOptions {
+    package?: string;
+    arguments: MarketKeyAtArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        index: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Compatibility helper for indexed reads. Returns unresolved market keys first,
+ * then resolved market keys. Prefer the linked-table cursor helpers for canonical
+ * traversal.
+ */
+export declare function marketKeyAt(options: MarketKeyAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketIdByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface MarketIdByKeyOptions {
+    package?: string;
+    arguments: MarketIdByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketIdByKey(options: MarketIdByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketExistsByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface MarketExistsByKeyOptions {
+    package?: string;
+    arguments: MarketExistsByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketExistsByKey(options: MarketExistsByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketIsResolvedByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface MarketIsResolvedByKeyOptions {
+    package?: string;
+    arguments: MarketIsResolvedByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketIsResolvedByKey(options: MarketIsResolvedByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketUnclaimedCountByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface MarketUnclaimedCountByKeyOptions {
+    package?: string;
+    arguments: MarketUnclaimedCountByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketUnclaimedCountByKey(options: MarketUnclaimedCountByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketExposureByKeyArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface MarketExposureByKeyOptions {
+    package?: string;
+    arguments: MarketExposureByKeyArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketExposureByKey(options: MarketExposureByKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnresolvedMarketsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface UnresolvedMarketsOptions {
+    package?: string;
+    arguments: UnresolvedMarketsArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unresolvedMarkets(options: UnresolvedMarketsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolvedMarketsArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface ResolvedMarketsOptions {
+    package?: string;
+    arguments: ResolvedMarketsArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function resolvedMarkets(options: ResolvedMarketsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnresolvedMarketCountArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface UnresolvedMarketCountOptions {
+    package?: string;
+    arguments: UnresolvedMarketCountArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unresolvedMarketCount(options: UnresolvedMarketCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolvedMarketCountArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface ResolvedMarketCountOptions {
+    package?: string;
+    arguments: ResolvedMarketCountArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function resolvedMarketCount(options: ResolvedMarketCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnresolvedMarketFrontArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface UnresolvedMarketFrontOptions {
+    package?: string;
+    arguments: UnresolvedMarketFrontArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unresolvedMarketFront(options: UnresolvedMarketFrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnresolvedMarketBackArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface UnresolvedMarketBackOptions {
+    package?: string;
+    arguments: UnresolvedMarketBackArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unresolvedMarketBack(options: UnresolvedMarketBackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolvedMarketFrontArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface ResolvedMarketFrontOptions {
+    package?: string;
+    arguments: ResolvedMarketFrontArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function resolvedMarketFront(options: ResolvedMarketFrontOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolvedMarketBackArguments {
+    marketRegistry: RawTransactionArgument<string>;
+}
+export interface ResolvedMarketBackOptions {
+    package?: string;
+    arguments: ResolvedMarketBackArguments | [
+        marketRegistry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function resolvedMarketBack(options: ResolvedMarketBackOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnresolvedMarketNextArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface UnresolvedMarketNextOptions {
+    package?: string;
+    arguments: UnresolvedMarketNextArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unresolvedMarketNext(options: UnresolvedMarketNextOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnresolvedMarketPrevArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface UnresolvedMarketPrevOptions {
+    package?: string;
+    arguments: UnresolvedMarketPrevArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unresolvedMarketPrev(options: UnresolvedMarketPrevOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolvedMarketNextArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface ResolvedMarketNextOptions {
+    package?: string;
+    arguments: ResolvedMarketNextArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function resolvedMarketNext(options: ResolvedMarketNextOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolvedMarketPrevArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    marketKey: RawTransactionArgument<number | bigint>;
+}
+export interface ResolvedMarketPrevOptions {
+    package?: string;
+    arguments: ResolvedMarketPrevArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        marketKey: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function resolvedMarketPrev(options: ResolvedMarketPrevOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StatusIsOpenArguments {
+    s: TransactionArgument;
+}
+export interface StatusIsOpenOptions {
+    package?: string;
+    arguments: StatusIsOpenArguments | [
+        s: TransactionArgument
+    ];
+}
+export declare function statusIsOpen(options: StatusIsOpenOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StatusIsPendingCloseArguments {
+    s: TransactionArgument;
+}
+export interface StatusIsPendingCloseOptions {
+    package?: string;
+    arguments: StatusIsPendingCloseArguments | [
+        s: TransactionArgument
+    ];
+}
+export declare function statusIsPendingClose(options: StatusIsPendingCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderKindIsOpenArguments {
+    kind: TransactionArgument;
+}
+export interface OrderKindIsOpenOptions {
+    package?: string;
+    arguments: OrderKindIsOpenArguments | [
+        kind: TransactionArgument
+    ];
+}
+export declare function orderKindIsOpen(options: OrderKindIsOpenOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OrderKindIsCloseArguments {
+    kind: TransactionArgument;
+}
+export interface OrderKindIsCloseOptions {
+    package?: string;
+    arguments: OrderKindIsCloseArguments | [
+        kind: TransactionArgument
+    ];
+}
+export declare function orderKindIsClose(options: OrderKindIsCloseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;