@waterx/sdk 3.0.1 → 3.1.0

package/dist/cjs/src/generated/waterx_perp/trading.d.ts

@@ -0,0 +1,2945 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Core trading engine for WaterX Perp DEX.
+ *
+ * User-side path uses a hot-potato `TradingRequest<C_TOKEN>` (no abilities),
+ * consumed in the same PTB by `trading::execute`. `execute` does the work inline
+ * and returns droppable `TradingResponse` receipts — user payouts route through
+ * `wxa_account::put`, not back out as a `Coin<C_TOKEN>`.
+ *
+ * PTB flow:
+ *
+ * 1.  let request = trading::place_order_request(...);
+ * 2.  // External rules add witnesses: my_rule::check(&mut request, ...);
+ * 3.  let responses = trading::execute(global_config, wxa_registry,
+ *     market_registry, ticker, pool, request, oracle, clock, ctx);
+ */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const Market: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Per-market configuration and state. */
+    config: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        symbol: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        is_paused: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+        max_leverage_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        min_coll_value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        trading_fee: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        max_impact_fee: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        allocated_lp_exposure_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        impact_fee_curvature: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        impact_fee_scale: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        maintenance_margin: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        max_long_oi: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        max_short_oi: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        cooldown_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        order_price_tick: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        max_pre_orders: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        basic_funding_rate: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        funding_interval_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        request_checklist: import("@mysten/sui/bcs").BcsType<{
+            name: string;
+        }[], Iterable<{
+            name: string;
+        }> & {
+            length: number;
+        }, string>;
+        position_locker: MoveStruct<any, any>;
+        long_oi: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        short_oi: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        long_avg_entry_price: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        short_avg_entry_price: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+        }, "bucket_v2_framework::float::Float">;
+        next_position_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        next_order_id: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        last_funding_timestamp: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        cumulative_funding_sign: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+        cumulative_funding_index: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u256">;
+        }, "bucket_v2_framework::double::Double">;
+    }, "@waterx/perp::market_config::MarketConfig">;
+    /** Positions indexed by position_id. */
+    positions: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        key_type: MoveStruct<{
+            name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        }, "std::type_name::TypeName">;
+        value_type: MoveStruct<{
+            name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        }, "std::type_name::TypeName">;
+        slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+        slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+        length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+    /** Limit buy orders: price_key → vector<Order> */
+    limit_buys: MoveStruct<{
+        levels: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+            key_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            value_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+            slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+            length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+    }, "@waterx/perp::order_book::OrderBook">;
+    /** Limit sell orders: price_key → vector<Order> */
+    limit_sells: MoveStruct<{
+        levels: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+            key_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            value_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+            slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+            length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+    }, "@waterx/perp::order_book::OrderBook">;
+    /** Stop buy orders: price_key → vector<Order> */
+    stop_buys: MoveStruct<{
+        levels: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+            key_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            value_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+            slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+            length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+    }, "@waterx/perp::order_book::OrderBook">;
+    /** Stop sell orders: price_key → vector<Order> */
+    stop_sells: MoveStruct<{
+        levels: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+            key_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            value_type: MoveStruct<{
+                name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+            }, "std::type_name::TypeName">;
+            slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+            slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+            length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+    }, "@waterx/perp::order_book::OrderBook">;
+    /**
+     * Reserved TP / SL pre-orders, keyed by the **pre-order's own `order_id`** (not
+     * the main order's id). Each entry is a single fully-formed reduce-only `Order`
+     * with `linked_position_id =  None`; on main fill `activate_pending_pre_orders`
+     * stamps in the new position id and moves the order onto the live book.
+     */
+    pending_pre_orders: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        key_type: MoveStruct<{
+            name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        }, "std::type_name::TypeName">;
+        value_type: MoveStruct<{
+            name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        }, "std::type_name::TypeName">;
+        slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+        slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+        length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+    /**
+     * Secondary index: `main_order_id → vector<pre_order_id>` listing the pre-orders
+     * reserved against each unfilled main. Used by activation / cancellation to
+     * enumerate the pre-orders that belong to a given main.
+     */
+    pending_pre_order_index: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        key_type: MoveStruct<{
+            name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        }, "std::type_name::TypeName">;
+        value_type: MoveStruct<{
+            name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        }, "std::type_name::TypeName">;
+        slice_idx: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+        slice_size: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+        length: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@waterx/perp::keyed_big_vector::KeyedBigVector">;
+}, "@waterx/perp::trading::Market<phantom LP_TOKEN>">;
+export declare const MarketRegistry: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Allowed protocol versions (admin-managed). */
+    allowed_versions: MoveStruct<any, any>;
+    /** Tickers of registered markets, mirrored from the DOF for cheap iteration. */
+    listed_tickers: import("@mysten/sui/bcs").BcsType<string[], Iterable<string> & {
+        length: number;
+    }, string>;
+}, "@waterx/perp::trading::MarketRegistry<phantom LP_TOKEN>">;
+export interface ActionOpenPositionOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionOpenPosition(options?: ActionOpenPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionClosePositionOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionClosePosition(options?: ActionClosePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionPlaceOrderOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionPlaceOrder(options?: ActionPlaceOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionCancelOrderOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionCancelOrder(options?: ActionCancelOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionDepositCollateralOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionDepositCollateral(options?: ActionDepositCollateralOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionWithdrawCollateralOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionWithdrawCollateral(options?: ActionWithdrawCollateralOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionLiquidateOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionLiquidate(options?: ActionLiquidateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionIncreasePositionOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionIncreasePosition(options?: ActionIncreasePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionDecreasePositionOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionDecreasePosition(options?: ActionDecreasePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionUpdateOrderOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionUpdateOrder(options?: ActionUpdateOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionCancelPreOrderOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionCancelPreOrder(options?: ActionCancelPreOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActionAddPreOrderOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function actionAddPreOrder(options?: ActionAddPreOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMarketArguments {
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    maxLeverageBps: RawTransactionArgument<number | bigint>;
+    minCollValue: RawTransactionArgument<number | bigint>;
+    tradingFee: RawTransactionArgument<number | bigint>;
+    maintenanceMargin: RawTransactionArgument<number | bigint>;
+    maxLongOi: RawTransactionArgument<number | bigint>;
+    maxShortOi: RawTransactionArgument<number | bigint>;
+    cooldownMs: RawTransactionArgument<number | bigint>;
+    basicFundingRate: RawTransactionArgument<number | bigint>;
+    fundingIntervalMs: RawTransactionArgument<number | bigint>;
+}
+export interface CreateMarketOptions {
+    package?: string;
+    arguments: CreateMarketArguments | [
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        maxLeverageBps: RawTransactionArgument<number | bigint>,
+        minCollValue: RawTransactionArgument<number | bigint>,
+        tradingFee: RawTransactionArgument<number | bigint>,
+        maintenanceMargin: RawTransactionArgument<number | bigint>,
+        maxLongOi: RawTransactionArgument<number | bigint>,
+        maxShortOi: RawTransactionArgument<number | bigint>,
+        cooldownMs: RawTransactionArgument<number | bigint>,
+        basicFundingRate: RawTransactionArgument<number | bigint>,
+        fundingIntervalMs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Creates a trading market with full configuration. `trading_fee`,
+ * `maintenance_margin`, and `basic_funding_rate` are scaled Float values (1e9
+ * scale). For example, a 5 bps fee = `500_000`.
+ */
+export declare function createMarket(options: CreateMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateMarketConfigArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    maxLeverageBps: RawTransactionArgument<number | bigint | null>;
+    minCollValue: RawTransactionArgument<number | bigint | null>;
+    tradingFee: RawTransactionArgument<number | bigint | null>;
+    maxImpactFee: RawTransactionArgument<number | bigint | null>;
+    allocatedLpExposureBps: RawTransactionArgument<number | bigint | null>;
+    impactFeeCurvature: RawTransactionArgument<number | bigint | null>;
+    impactFeeScale: RawTransactionArgument<number | bigint | null>;
+    maintenanceMargin: RawTransactionArgument<number | bigint | null>;
+    maxLongOi: RawTransactionArgument<number | bigint | null>;
+    maxShortOi: RawTransactionArgument<number | bigint | null>;
+    cooldownMs: RawTransactionArgument<number | bigint | null>;
+    orderPriceTick: RawTransactionArgument<number | bigint | null>;
+    maxPreOrders: RawTransactionArgument<number | bigint | null>;
+    basicFundingRate: RawTransactionArgument<number | bigint | null>;
+    fundingIntervalMs: RawTransactionArgument<number | bigint | null>;
+}
+export interface UpdateMarketConfigOptions {
+    package?: string;
+    arguments: UpdateMarketConfigArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        maxLeverageBps: RawTransactionArgument<number | bigint | null>,
+        minCollValue: RawTransactionArgument<number | bigint | null>,
+        tradingFee: RawTransactionArgument<number | bigint | null>,
+        maxImpactFee: RawTransactionArgument<number | bigint | null>,
+        allocatedLpExposureBps: RawTransactionArgument<number | bigint | null>,
+        impactFeeCurvature: RawTransactionArgument<number | bigint | null>,
+        impactFeeScale: RawTransactionArgument<number | bigint | null>,
+        maintenanceMargin: RawTransactionArgument<number | bigint | null>,
+        maxLongOi: RawTransactionArgument<number | bigint | null>,
+        maxShortOi: RawTransactionArgument<number | bigint | null>,
+        cooldownMs: RawTransactionArgument<number | bigint | null>,
+        orderPriceTick: RawTransactionArgument<number | bigint | null>,
+        maxPreOrders: RawTransactionArgument<number | bigint | null>,
+        basicFundingRate: RawTransactionArgument<number | bigint | null>,
+        fundingIntervalMs: RawTransactionArgument<number | bigint | null>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: forwards to `market_config::update_market_config` through the shared
+ * `Market`. Needed because `MarketConfig` is embedded inside `Market` and can't be
+ * borrowed mutably from a PTB directly. Funding parameters must be updated with
+ * `update_market_funding_config` so accrued funding is settled under the old
+ * parameters before the new parameters take effect.
+ */
+export declare function updateMarketConfig(options: UpdateMarketConfigOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateMarketFundingConfigArguments {
+    globalConfig: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    basicFundingRate: RawTransactionArgument<number | bigint | null>;
+    fundingIntervalMs: RawTransactionArgument<number | bigint | null>;
+}
+export interface UpdateMarketFundingConfigOptions {
+    package?: string;
+    arguments: UpdateMarketFundingConfigArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        basicFundingRate: RawTransactionArgument<number | bigint | null>,
+        fundingIntervalMs: RawTransactionArgument<number | bigint | null>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: settles accrued funding under the old funding parameters, then updates
+ * funding parameters for future intervals.
+ */
+export declare function updateMarketFundingConfig(options: UpdateMarketFundingConfigOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PauseMarketArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface PauseMarketOptions {
+    package?: string;
+    arguments: PauseMarketArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Admin: suspend the market (halts trading). */
+export declare function pauseMarket(options: PauseMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnpauseMarketArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface UnpauseMarketOptions {
+    package?: string;
+    arguments: UnpauseMarketArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Admin: resume the market. */
+export declare function unpauseMarket(options: UnpauseMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddRequestRuleArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface AddRequestRuleOptions {
+    package?: string;
+    arguments: AddRequestRuleArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Admin: add witness type `W` to the request checklist. */
+export declare function addRequestRule(options: AddRequestRuleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveRequestRuleArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface RemoveRequestRuleOptions {
+    package?: string;
+    arguments: RemoveRequestRuleArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Admin: remove witness type `W` from the request checklist. */
+export declare function removeRequestRule(options: RemoveRequestRuleOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegisterMarketAumArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    aum: RawTransactionArgument<string>;
+    cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+}
+export interface RegisterMarketAumOptions {
+    package?: string;
+    arguments: RegisterMarketAumArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        aum: RawTransactionArgument<string>,
+        cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Registers a market in the pool-level WLP AUM object. */
+export declare function registerMarketAum(options: RegisterMarketAumOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RefreshMarketAumArguments {
+    marketRegistry: RawTransactionArgument<string>;
+    aum: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+}
+export interface RefreshMarketAumOptions {
+    package?: string;
+    arguments: RefreshMarketAumArguments | [
+        marketRegistry: RawTransactionArgument<string>,
+        aum: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Refreshes one registered market's contribution to pool-level WLP AUM. */
+export declare function refreshMarketAum(options: RefreshMarketAumOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertProtocolPermArguments {
+    wxaRegistry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    sender: RawTransactionArgument<string>;
+    permission: RawTransactionArgument<number>;
+}
+export interface AssertProtocolPermOptions {
+    package?: string;
+    arguments: AssertProtocolPermArguments | [
+        wxaRegistry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        sender: RawTransactionArgument<string>,
+        permission: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Permission check on the wxa account for the trading entrypoints. Reads
+ * `effective_protocol_permissions<TradingRequest<C_TOKEN>>` so per-collateral
+ * granularity is preserved (`PERM_OPEN_POSITION` etc. are bits on that bitmap).
+ * Must be called _before_ any `wxa_account::take` so a failed auth doesn't leave
+ * the user drained.
+ */
+export declare function assertProtocolPerm(options: AssertProtocolPermOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ClosePositionRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface ClosePositionRequestOptions {
+    package?: string;
+    arguments: ClosePositionRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Creates a request to close a position. */
+export declare function closePositionRequest(options: ClosePositionRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IncreasePositionRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint | null>;
+    positionId: RawTransactionArgument<number | bigint>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+    size: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface IncreasePositionRequestOptions {
+    package?: string;
+    arguments: IncreasePositionRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint | null>,
+        positionId: RawTransactionArgument<number | bigint>,
+        collateralAmount: RawTransactionArgument<number | bigint>,
+        size: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Creates a request to increase an existing position at market. */
+export declare function increasePositionRequest(options: IncreasePositionRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DecreasePositionRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    size: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface DecreasePositionRequestOptions {
+    package?: string;
+    arguments: DecreasePositionRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        size: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Creates a request to partially reduce an existing position at market. */
+export declare function decreasePositionRequest(options: DecreasePositionRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PlaceOrderRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    main: TransactionArgument;
+    preOrder: TransactionArgument;
+}
+export interface PlaceOrderRequestOptions {
+    package?: string;
+    arguments: PlaceOrderRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        main: TransactionArgument,
+        preOrder: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Creates a request to place a limit, stop, or market order, optionally with TP/SL
+ * pre-orders reserved against the freshly opened position.
+ *
+ * `main: PlaceOrderArgument` describes the order that hits the book immediately.
+ * `pre_order: vector<PlaceOrderArgument>` (length 0..=2) describes reduce-only
+ * orders that will be promoted to real linked orders on the new position when the
+ * main fills via `match_orders`.
+ *
+ * `main.trigger_price = None` is the market form: the order is parked at tick 0 in
+ * the limit book and a keeper fills it via `match_orders` at the live oracle.
+ * `acceptable_price` is carried on the order and consulted at match time — if the
+ * oracle moves past it the order is cancelled and collateral refunded. Limit/stop
+ * orders ignore `acceptable_price`.
+ *
+ * Validation runs _before_ the wxa take so a malformed request never drains the
+ * user's balance.
+ */
+export declare function placeOrderRequest(options: PlaceOrderRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ValidatePreOrdersArguments {
+    main: TransactionArgument;
+    preOrder: TransactionArgument;
+    maxPreOrders: RawTransactionArgument<number | bigint>;
+}
+export interface ValidatePreOrdersOptions {
+    package?: string;
+    arguments: ValidatePreOrdersArguments | [
+        main: TransactionArgument,
+        preOrder: TransactionArgument,
+        maxPreOrders: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Validates `(main, pre_order)` at place-order request creation. Combines the
+ * main-eligibility check (must be a fresh opening order), the count check against
+ * the market-level cap, and per-entry structural rules.
+ */
+export declare function validatePreOrders(options: ValidatePreOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ValidatePreOrderEntriesArguments {
+    mainIsLong: RawTransactionArgument<boolean>;
+    preOrder: TransactionArgument;
+}
+export interface ValidatePreOrderEntriesOptions {
+    package?: string;
+    arguments: ValidatePreOrderEntriesArguments | [
+        mainIsLong: RawTransactionArgument<boolean>,
+        preOrder: TransactionArgument
+    ];
+}
+/**
+ * Per-entry structural validation only: reduce-only, real trigger, no collateral,
+ * no pre-picked link target, opposite side of main, non-zero size. The total-count
+ * check is the caller's responsibility (`assert_pre_order_count`) so this can be
+ * reused from per-leg add / cancel paths.
+ */
+export declare function validatePreOrderEntries(options: ValidatePreOrderEntriesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertPreOrderCountArguments {
+    newTotal: RawTransactionArgument<number | bigint>;
+    maxPreOrders: RawTransactionArgument<number | bigint>;
+}
+export interface AssertPreOrderCountOptions {
+    package?: string;
+    arguments: AssertPreOrderCountArguments | [
+        newTotal: RawTransactionArgument<number | bigint>,
+        maxPreOrders: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Caps the **total** pre-orders reserved against a single main at the
+ * market-config `max_pre_orders`. Aborts with `ETooManyPreOrders`.
+ */
+export declare function assertPreOrderCount(options: AssertPreOrderCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CancelOrderRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    triggerPrice: RawTransactionArgument<number | bigint>;
+    orderTypeTag: RawTransactionArgument<number>;
+}
+export interface CancelOrderRequestOptions {
+    package?: string;
+    arguments: CancelOrderRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        triggerPrice: RawTransactionArgument<number | bigint>,
+        orderTypeTag: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Creates a request to cancel an order. `order_type_tag = 255` scans all 4 books
+ * for the matching `order_id`. `trigger_price` is the scaled `Float` value; `0`
+ * scans all trigger price buckets in the selected book(s).
+ */
+export declare function cancelOrderRequest(options: CancelOrderRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateOrderRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    currentTriggerPrice: RawTransactionArgument<number | bigint>;
+    orderTypeTag: RawTransactionArgument<number>;
+    newSize: RawTransactionArgument<number | bigint>;
+    newTriggerPrice: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateOrderRequestOptions {
+    package?: string;
+    arguments: UpdateOrderRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        currentTriggerPrice: RawTransactionArgument<number | bigint>,
+        orderTypeTag: RawTransactionArgument<number>,
+        newSize: RawTransactionArgument<number | bigint>,
+        newTriggerPrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Creates a request to update a live order's size and trigger price. The order
+ * keeps its direction, reduce-only flag, linked position, collateral, and
+ * limit/stop book. `order_type_tag = 255` and `current_trigger_price = 0` scan for
+ * the current order location.
+ */
+export declare function updateOrderRequest(options: UpdateOrderRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CancelPreOrderRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+    preOrderId: RawTransactionArgument<number | bigint>;
+}
+export interface CancelPreOrderRequestOptions {
+    package?: string;
+    arguments: CancelPreOrderRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>,
+        preOrderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Cancels a single TP / SL pre-order reserved against an unfilled main.
+ * `pre_order_id` is the pre-order's own `order_id`, returned in the `OrderCreated`
+ * event when it activates (also enumerable from `pending_pre_order_index` keyed by
+ * `main_order_id`). The pair must be consistent — i.e. `pre_order_id` must appear
+ * in the index entry for `main_order_id`, otherwise the call aborts with
+ * `EOrderNotFound`. Pre-orders never hold collateral, so this only adjusts
+ * bookkeeping; no payout. Emits `PreOrderCancelled` with `pre_order_count = 1`.
+ */
+export declare function cancelPreOrderRequest(options: CancelPreOrderRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddPreOrderRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+    preOrder: TransactionArgument;
+}
+export interface AddPreOrderRequestOptions {
+    package?: string;
+    arguments: AddPreOrderRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>,
+        preOrder: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Adds one TP / SL pre-order to an unfilled main. The main must still be on the
+ * book, owned by `account_id`, of collateral type `C_TOKEN`, and a fresh opening
+ * order. The per-entry rules (`validate_pre_order_entries`) and the market-level
+ * total cap (`market.config.max_pre_orders()`) are enforced — existing reserved
+ *
+ * - 1 must stay within cap.
+ */
+export declare function addPreOrderRequest(options: AddPreOrderRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositCollateralRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+}
+export interface DepositCollateralRequestOptions {
+    package?: string;
+    arguments: DepositCollateralRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        collateralAmount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Creates a request to deposit collateral on a position. */
+export declare function depositCollateralRequest(options: DepositCollateralRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawCollateralRequestArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface WithdrawCollateralRequestOptions {
+    package?: string;
+    arguments: WithdrawCollateralRequestArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/** Creates a request to withdraw collateral from a position. */
+export declare function withdrawCollateralRequest(options: WithdrawCollateralRequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LiquidateArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    oracle: RawTransactionArgument<string>;
+}
+export interface LiquidateOptions {
+    package?: string;
+    arguments: LiquidateArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Creates a request to liquidate a position (keeper only). Reads
+ * account_object_address from the position directly. Keeper-only: liquidate an
+ * undercollateralized position. Single-call — no `TradingRequest` hot potato to
+ * manage. Returns a droppable receipt vector for PTB composition.
+ */
+export declare function liquidate(options: LiquidateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BatchLiquidateArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    oracle: RawTransactionArgument<string>;
+    pageSize: RawTransactionArgument<number | bigint>;
+    pageIndex: RawTransactionArgument<number | bigint>;
+}
+export interface BatchLiquidateOptions {
+    package?: string;
+    arguments: BatchLiquidateArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        oracle: RawTransactionArgument<string>,
+        pageSize: RawTransactionArgument<number | bigint>,
+        pageIndex: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Keeper-only: scans a page of positions and liquidates every liquidatable one.
+ * Iterates positions by internal index `[page_index * page_size, ...)`. No-op if
+ * the page is out of range or no positions qualify. Returns droppable receipts for
+ * every liquidated position.
+ */
+export declare function batchLiquidate(options: BatchLiquidateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    req: TransactionArgument;
+    oracle: RawTransactionArgument<string>;
+}
+export interface ExecuteOptions {
+    package?: string;
+    arguments: ExecuteArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        req: TransactionArgument,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Executes a trading request. All `*_request` creators return raw
+ * `TradingRequest<C>`; pass it straight to `execute` after attaching any witness
+ * rules (e.g. `pyth_rule::feed(&mut req, ...)`). Used by both user happy paths and
+ * keeper paths.
+ */
+export declare function execute(options: ExecuteOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteOpenPositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    sender: RawTransactionArgument<string>;
+    collateral: TransactionArgument;
+    isLong: RawTransactionArgument<boolean>;
+    size: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteOpenPositionOptions {
+    package?: string;
+    arguments: ExecuteOpenPositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        sender: RawTransactionArgument<string>,
+        collateral: TransactionArgument,
+        isLong: RawTransactionArgument<boolean>,
+        size: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeOpenPosition(options: ExecuteOpenPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteIncreasePositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    positionId: RawTransactionArgument<number | bigint>;
+    collateral: TransactionArgument;
+    size: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteIncreasePositionOptions {
+    package?: string;
+    arguments: ExecuteIncreasePositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        positionId: RawTransactionArgument<number | bigint>,
+        collateral: TransactionArgument,
+        size: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeIncreasePosition(options: ExecuteIncreasePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteClosePositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    accountObjId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    positionId: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteClosePositionOptions {
+    package?: string;
+    arguments: ExecuteClosePositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        accountObjId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        positionId: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeClosePosition(options: ExecuteClosePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteDecreasePositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    accountObjId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    positionId: RawTransactionArgument<number | bigint>;
+    requestedSize: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteDecreasePositionOptions {
+    package?: string;
+    arguments: ExecuteDecreasePositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        accountObjId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        positionId: RawTransactionArgument<number | bigint>,
+        requestedSize: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeDecreasePosition(options: ExecuteDecreasePositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecutePlaceOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    collateral: TransactionArgument;
+    isLong: RawTransactionArgument<boolean>;
+    isStopOrder: RawTransactionArgument<boolean>;
+    reduceOnly: RawTransactionArgument<boolean>;
+    size: TransactionArgument;
+    triggerPrice: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+    linkedPositionId: RawTransactionArgument<number | bigint | null>;
+    preOrders: TransactionArgument;
+}
+export interface ExecutePlaceOrderOptions {
+    package?: string;
+    arguments: ExecutePlaceOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        collateral: TransactionArgument,
+        isLong: RawTransactionArgument<boolean>,
+        isStopOrder: RawTransactionArgument<boolean>,
+        reduceOnly: RawTransactionArgument<boolean>,
+        size: TransactionArgument,
+        triggerPrice: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>,
+        linkedPositionId: RawTransactionArgument<number | bigint | null>,
+        preOrders: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executePlaceOrder(options: ExecutePlaceOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteCancelOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    accountObjId: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    triggerPriceKey: RawTransactionArgument<number | bigint>;
+    orderTypeTag: RawTransactionArgument<number>;
+}
+export interface ExecuteCancelOrderOptions {
+    package?: string;
+    arguments: ExecuteCancelOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        accountObjId: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        triggerPriceKey: RawTransactionArgument<number | bigint>,
+        orderTypeTag: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeCancelOrder(options: ExecuteCancelOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteUpdateOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    orderId: RawTransactionArgument<number | bigint>;
+    triggerPriceKey: RawTransactionArgument<number | bigint>;
+    orderTypeTag: RawTransactionArgument<number>;
+    newSize: TransactionArgument;
+    newTriggerPrice: TransactionArgument;
+}
+export interface ExecuteUpdateOrderOptions {
+    package?: string;
+    arguments: ExecuteUpdateOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        orderId: RawTransactionArgument<number | bigint>,
+        triggerPriceKey: RawTransactionArgument<number | bigint>,
+        orderTypeTag: RawTransactionArgument<number>,
+        newSize: TransactionArgument,
+        newTriggerPrice: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeUpdateOrder(options: ExecuteUpdateOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteCancelPreOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+    preOrderId: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteCancelPreOrderOptions {
+    package?: string;
+    arguments: ExecuteCancelPreOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>,
+        preOrderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Cancels a single pre-order by id. Validates ownership / collateral type on the
+ * reserved `Order`, then verifies `pre_order_id` actually belongs to
+ * `main_order_id` via the index. Destroys the `Order` through
+ * `position::remove_order<C_TOKEN>` and emits
+ * `PreOrderCancelled { main_order_id, pre_order_count: 1 }`.
+ */
+export declare function executeCancelPreOrder(options: ExecuteCancelPreOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteAddPreOrderArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+    newPreOrder: TransactionArgument;
+}
+export interface ExecuteAddPreOrderOptions {
+    package?: string;
+    arguments: ExecuteAddPreOrderArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>,
+        newPreOrder: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Appends a single pre-order to an existing or empty reservation for
+ * `main_order_id`. Locates the main on a book, verifies eligibility, then
+ * `assert_pre_order_count(existing + 1, cap)` and per-entry validation before
+ * delegating to `reserve_pre_orders`.
+ */
+export declare function executeAddPreOrder(options: ExecuteAddPreOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteDepositCollateralArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    collateral: TransactionArgument;
+}
+export interface ExecuteDepositCollateralOptions {
+    package?: string;
+    arguments: ExecuteDepositCollateralArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        collateral: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeDepositCollateral(options: ExecuteDepositCollateralOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteWithdrawCollateralArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjId: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteWithdrawCollateralOptions {
+    package?: string;
+    arguments: ExecuteWithdrawCollateralArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjId: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns `(returned_collateral_amount, position_collateral_amount)`: the first is
+ * the amount actually credited back to the wxa account (read off the `Balance`
+ * rather than echoing the requested `amount`, so the response field can't drift if
+ * `pos.withdraw_collateral` ever gains clamping semantics); the second is the
+ * post-action position collateral.
+ */
+export declare function executeWithdrawCollateral(options: ExecuteWithdrawCollateralOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ExecuteLiquidateArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    sender: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface ExecuteLiquidateOptions {
+    package?: string;
+    arguments: ExecuteLiquidateArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        sender: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function executeLiquidate(options: ExecuteLiquidateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MatchOrdersArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    oracle: RawTransactionArgument<string>;
+    orderTypeTag: RawTransactionArgument<number>;
+    triggerPrice: RawTransactionArgument<number | bigint>;
+    maxFills: RawTransactionArgument<number | bigint>;
+}
+export interface MatchOrdersOptions {
+    package?: string;
+    arguments: MatchOrdersArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        oracle: RawTransactionArgument<string>,
+        orderTypeTag: RawTransactionArgument<number>,
+        triggerPrice: RawTransactionArgument<number | bigint>,
+        maxFills: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function matchOrders(options: MatchOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateFundingRateArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+}
+export interface UpdateFundingRateOptions {
+    package?: string;
+    arguments: UpdateFundingRateArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Keeper: updates funding rate for a market. */
+export declare function updateFundingRate(options: UpdateFundingRateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleFundingRateArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+}
+export interface SettleFundingRateOptions {
+    package?: string;
+    arguments: SettleFundingRateArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function settleFundingRate(options: SettleFundingRateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OpenPositionByKeeperArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    accountObjectAddress: RawTransactionArgument<string>;
+    collateralCoin: RawTransactionArgument<string>;
+    isLong: RawTransactionArgument<boolean>;
+    size: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+    oracle: RawTransactionArgument<string>;
+}
+export interface OpenPositionByKeeperOptions {
+    package?: string;
+    arguments: OpenPositionByKeeperArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        accountObjectAddress: RawTransactionArgument<string>,
+        collateralCoin: RawTransactionArgument<string>,
+        isLong: RawTransactionArgument<boolean>,
+        size: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Keeper-only: open a new position for an account, funded by the keeper's own
+ * `Coin<C_TOKEN>` (campaign / airdrop use case). The keeper bypasses
+ * `min_coll_value` on this path — `increase_position` and `place_order` still
+ * enforce it for all callers including keepers. Returns a droppable receipt vector
+ * so the keeper or a composing protocol can reference the position in the same
+ * PTB.
+ */
+export declare function openPositionByKeeper(options: OpenPositionByKeeperOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ClosePositionByKeeperArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    marketRegistry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    keeperRequest: TransactionArgument;
+    positionId: RawTransactionArgument<number | bigint>;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+    oracle: RawTransactionArgument<string>;
+}
+export interface ClosePositionByKeeperOptions {
+    package?: string;
+    arguments: ClosePositionByKeeperArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        marketRegistry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        keeperRequest: TransactionArgument,
+        positionId: RawTransactionArgument<number | bigint>,
+        acceptablePrice: RawTransactionArgument<number | bigint>,
+        oracle: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Risk-manager-only: force-close a position (emergency use). Reads
+ * `account_object_address` from the position directly, like `liquidate`. Returns a
+ * droppable receipt vector for PTB composition.
+ */
+export declare function closePositionByKeeper(options: ClosePositionByKeeperOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolveSizeArguments {
+    market: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+    leverageBps: RawTransactionArgument<number | bigint>;
+}
+export interface ResolveSizeOptions {
+    package?: string;
+    arguments: ResolveSizeArguments | [
+        market: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        collateralAmount: RawTransactionArgument<number | bigint>,
+        leverageBps: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Computes the scaled size (u128, 9 decimals) for a given collateral amount,
+ * leverage, and actual collateral price. Compatible with non-dollar-pegged
+ * collateral. Base ticker comes from `market.symbol()`, collateral ticker from
+ * `pool.token_ticker<LP, C>()` — callers cannot mis-price by lying about either.
+ */
+export declare function resolveSize(options: ResolveSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ResolveOrderSizeArguments {
+    pool: RawTransactionArgument<string>;
+    oracle: RawTransactionArgument<string>;
+    triggerPrice: RawTransactionArgument<number | bigint>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+    leverageBps: RawTransactionArgument<number | bigint>;
+}
+export interface ResolveOrderSizeOptions {
+    package?: string;
+    arguments: ResolveOrderSizeArguments | [
+        pool: RawTransactionArgument<string>,
+        oracle: RawTransactionArgument<string>,
+        triggerPrice: RawTransactionArgument<number | bigint>,
+        collateralAmount: RawTransactionArgument<number | bigint>,
+        leverageBps: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Like `resolve_size` but uses a trigger price instead of the base oracle price.
+ * Use this to compute the `size` parameter for `place_order_request`.
+ * `trigger_price` is a scaled Float value (the same u128 you pass to
+ * `place_order_request`).
+ */
+export declare function resolveOrderSize(options: ResolveOrderSizeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CheckOpenSlippageArguments {
+    isLong: RawTransactionArgument<boolean>;
+    price: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface CheckOpenSlippageOptions {
+    package?: string;
+    arguments: CheckOpenSlippageArguments | [
+        isLong: RawTransactionArgument<boolean>,
+        price: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function checkOpenSlippage(options: CheckOpenSlippageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertOpenSlippageArguments {
+    isLong: RawTransactionArgument<boolean>;
+    price: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface AssertOpenSlippageOptions {
+    package?: string;
+    arguments: AssertOpenSlippageArguments | [
+        isLong: RawTransactionArgument<boolean>,
+        price: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function assertOpenSlippage(options: AssertOpenSlippageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertCloseSlippageArguments {
+    isLong: RawTransactionArgument<boolean>;
+    price: TransactionArgument;
+    acceptablePrice: RawTransactionArgument<number | bigint>;
+}
+export interface AssertCloseSlippageOptions {
+    package?: string;
+    arguments: AssertCloseSlippageArguments | [
+        isLong: RawTransactionArgument<boolean>,
+        price: TransactionArgument,
+        acceptablePrice: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function assertCloseSlippage(options: AssertCloseSlippageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CalculateTotalTradingFeeArguments {
+    marketConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    executionPrice: TransactionArgument;
+    orderIsLong: RawTransactionArgument<boolean>;
+    orderSize: TransactionArgument;
+}
+export interface CalculateTotalTradingFeeOptions {
+    package?: string;
+    arguments: CalculateTotalTradingFeeArguments | [
+        marketConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        executionPrice: TransactionArgument,
+        orderIsLong: RawTransactionArgument<boolean>,
+        orderSize: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function calculateTotalTradingFee(options: CalculateTotalTradingFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EmitLpEquityArguments {
+    market: RawTransactionArgument<string>;
+    collateralToken: TransactionArgument;
+    amount: RawTransactionArgument<number | bigint>;
+    isProfit: RawTransactionArgument<boolean>;
+    memo: RawTransactionArgument<string>;
+}
+export interface EmitLpEquityOptions {
+    package?: string;
+    arguments: EmitLpEquityArguments | [
+        market: RawTransactionArgument<string>,
+        collateralToken: TransactionArgument,
+        amount: RawTransactionArgument<number | bigint>,
+        isProfit: RawTransactionArgument<boolean>,
+        memo: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Emits a `WlpEquityChanged` event for a settlement that moves `amount` of
+ * `collateral_token` to/from the LP pool. No-op when `amount == 0`. Centralizes
+ * the `market.symbol()` / `with_defining_ids<LP_TOKEN>()` lookups so call sites
+ * stay short.
+ */
+export declare function emitLpEquity(options: EmitLpEquityOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DistributeTradingFeeArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    feeBalance: TransactionArgument;
+    protocolShareBps: RawTransactionArgument<number | bigint>;
+    marketId: RawTransactionArgument<string>;
+    collateralToken: TransactionArgument;
+    collateralPrice: TransactionArgument;
+}
+export interface DistributeTradingFeeOptions {
+    package?: string;
+    arguments: DistributeTradingFeeArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        feeBalance: TransactionArgument,
+        protocolShareBps: RawTransactionArgument<number | bigint>,
+        marketId: RawTransactionArgument<string>,
+        collateralToken: TransactionArgument,
+        collateralPrice: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Splits an already-collected trading-fee balance into the protocol's cut (sent to
+ * `GlobalVault.protocol_fee_balance`) and the LP pool's cut (joined into the pool,
+ * emitted as a `WlpEquityChanged` "fee" event). Used by every closing/liquidation
+ * path that realizes a fee.
+ */
+export declare function distributeTradingFee(options: DistributeTradingFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CalculateEffectiveCollateralAmountArguments {
+    grossCollateralAmount: RawTransactionArgument<number | bigint>;
+    borrowFee: RawTransactionArgument<number | bigint>;
+    fundingSign: RawTransactionArgument<boolean>;
+    fundingFee: RawTransactionArgument<number | bigint>;
+    tradingFee: RawTransactionArgument<number | bigint>;
+    projectedTradingFee: RawTransactionArgument<number | bigint>;
+}
+export interface CalculateEffectiveCollateralAmountOptions {
+    package?: string;
+    arguments: CalculateEffectiveCollateralAmountArguments | [
+        grossCollateralAmount: RawTransactionArgument<number | bigint>,
+        borrowFee: RawTransactionArgument<number | bigint>,
+        fundingSign: RawTransactionArgument<boolean>,
+        fundingFee: RawTransactionArgument<number | bigint>,
+        tradingFee: RawTransactionArgument<number | bigint>,
+        projectedTradingFee: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function calculateEffectiveCollateralAmount(options: CalculateEffectiveCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CalculateLossAdjustedEffectiveCollateralAmountArguments {
+    position: RawTransactionArgument<string>;
+    currentPrice: TransactionArgument;
+    collateralPrice: TransactionArgument;
+    grossCollateralAmount: RawTransactionArgument<number | bigint>;
+    borrowFee: RawTransactionArgument<number | bigint>;
+    fundingSign: RawTransactionArgument<boolean>;
+    fundingFee: RawTransactionArgument<number | bigint>;
+    tradingFee: RawTransactionArgument<number | bigint>;
+    projectedTradingFee: RawTransactionArgument<number | bigint>;
+}
+export interface CalculateLossAdjustedEffectiveCollateralAmountOptions {
+    package?: string;
+    arguments: CalculateLossAdjustedEffectiveCollateralAmountArguments | [
+        position: RawTransactionArgument<string>,
+        currentPrice: TransactionArgument,
+        collateralPrice: TransactionArgument,
+        grossCollateralAmount: RawTransactionArgument<number | bigint>,
+        borrowFee: RawTransactionArgument<number | bigint>,
+        fundingSign: RawTransactionArgument<boolean>,
+        fundingFee: RawTransactionArgument<number | bigint>,
+        tradingFee: RawTransactionArgument<number | bigint>,
+        projectedTradingFee: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function calculateLossAdjustedEffectiveCollateralAmount(options: CalculateLossAdjustedEffectiveCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleLossToBalanceArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    collateral: TransactionArgument;
+    collateralToken: TransactionArgument;
+    lossAmount: RawTransactionArgument<number | bigint>;
+    collateralPrice: TransactionArgument;
+    deficit: RawTransactionArgument<number | bigint>;
+}
+export interface SettleLossToBalanceOptions {
+    package?: string;
+    arguments: SettleLossToBalanceArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        collateral: TransactionArgument,
+        collateralToken: TransactionArgument,
+        lossAmount: RawTransactionArgument<number | bigint>,
+        collateralPrice: TransactionArgument,
+        deficit: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function settleLossToBalance(options: SettleLossToBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleLossToPositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    position: RawTransactionArgument<string>;
+    collateralToken: TransactionArgument;
+    lossAmount: RawTransactionArgument<number | bigint>;
+    collateralPrice: TransactionArgument;
+    deficit: RawTransactionArgument<number | bigint>;
+}
+export interface SettleLossToPositionOptions {
+    package?: string;
+    arguments: SettleLossToPositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        position: RawTransactionArgument<string>,
+        collateralToken: TransactionArgument,
+        lossAmount: RawTransactionArgument<number | bigint>,
+        collateralPrice: TransactionArgument,
+        deficit: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function settleLossToPosition(options: SettleLossToPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleFeesToBalanceArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    collateral: TransactionArgument;
+    protocolShareBps: RawTransactionArgument<number | bigint>;
+    marketId: RawTransactionArgument<string>;
+    collateralToken: TransactionArgument;
+    collateralPrice: TransactionArgument;
+    feeAmount: RawTransactionArgument<number | bigint>;
+    deficit: RawTransactionArgument<number | bigint>;
+}
+export interface SettleFeesToBalanceOptions {
+    package?: string;
+    arguments: SettleFeesToBalanceArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        collateral: TransactionArgument,
+        protocolShareBps: RawTransactionArgument<number | bigint>,
+        marketId: RawTransactionArgument<string>,
+        collateralToken: TransactionArgument,
+        collateralPrice: TransactionArgument,
+        feeAmount: RawTransactionArgument<number | bigint>,
+        deficit: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function settleFeesToBalance(options: SettleFeesToBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleFeesToPositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    position: RawTransactionArgument<string>;
+    protocolShareBps: RawTransactionArgument<number | bigint>;
+    marketId: RawTransactionArgument<string>;
+    collateralToken: TransactionArgument;
+    collateralPrice: TransactionArgument;
+    feeAmount: RawTransactionArgument<number | bigint>;
+    deficit: RawTransactionArgument<number | bigint>;
+}
+export interface SettleFeesToPositionOptions {
+    package?: string;
+    arguments: SettleFeesToPositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        position: RawTransactionArgument<string>,
+        protocolShareBps: RawTransactionArgument<number | bigint>,
+        marketId: RawTransactionArgument<string>,
+        collateralToken: TransactionArgument,
+        collateralPrice: TransactionArgument,
+        feeAmount: RawTransactionArgument<number | bigint>,
+        deficit: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function settleFeesToPosition(options: SettleFeesToPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleFundingToBalanceArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    collateral: TransactionArgument;
+    fundingSign: RawTransactionArgument<boolean>;
+    fundingFee: RawTransactionArgument<number | bigint>;
+    collateralPrice: TransactionArgument;
+    marketTicker: RawTransactionArgument<string>;
+    deficit: RawTransactionArgument<number | bigint>;
+}
+export interface SettleFundingToBalanceOptions {
+    package?: string;
+    arguments: SettleFundingToBalanceArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        collateral: TransactionArgument,
+        fundingSign: RawTransactionArgument<boolean>,
+        fundingFee: RawTransactionArgument<number | bigint>,
+        collateralPrice: TransactionArgument,
+        marketTicker: RawTransactionArgument<string>,
+        deficit: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function settleFundingToBalance(options: SettleFundingToBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SettleFundingToPositionArguments {
+    globalConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    position: RawTransactionArgument<string>;
+    fundingSign: RawTransactionArgument<boolean>;
+    fundingFee: RawTransactionArgument<number | bigint>;
+    collateralPrice: TransactionArgument;
+    marketTicker: RawTransactionArgument<string>;
+    deficit: RawTransactionArgument<number | bigint>;
+}
+export interface SettleFundingToPositionOptions {
+    package?: string;
+    arguments: SettleFundingToPositionArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        position: RawTransactionArgument<string>,
+        fundingSign: RawTransactionArgument<boolean>,
+        fundingFee: RawTransactionArgument<number | bigint>,
+        collateralPrice: TransactionArgument,
+        marketTicker: RawTransactionArgument<string>,
+        deficit: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function settleFundingToPosition(options: SettleFundingToPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CalculateImpactFeeArguments {
+    marketConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    executionPrice: TransactionArgument;
+    orderIsLong: RawTransactionArgument<boolean>;
+    orderSize: TransactionArgument;
+}
+export interface CalculateImpactFeeOptions {
+    package?: string;
+    arguments: CalculateImpactFeeArguments | [
+        marketConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        executionPrice: TransactionArgument,
+        orderIsLong: RawTransactionArgument<boolean>,
+        orderSize: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function calculateImpactFee(options: CalculateImpactFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ImpactFeeCostUsdArguments {
+    maxImpactFee: TransactionArgument;
+    allocatedExposureUsd: TransactionArgument;
+    exposureUsd: TransactionArgument;
+    impactFeeCurvature: RawTransactionArgument<number | bigint>;
+    impactFeeScale: RawTransactionArgument<number | bigint>;
+}
+export interface ImpactFeeCostUsdOptions {
+    package?: string;
+    arguments: ImpactFeeCostUsdArguments | [
+        maxImpactFee: TransactionArgument,
+        allocatedExposureUsd: TransactionArgument,
+        exposureUsd: TransactionArgument,
+        impactFeeCurvature: RawTransactionArgument<number | bigint>,
+        impactFeeScale: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function impactFeeCostUsd(options: ImpactFeeCostUsdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CalculatePositionLeverageBpsArguments {
+    totalSize: TransactionArgument;
+    totalCollateralAmount: RawTransactionArgument<number | bigint>;
+    collateralDecimal: RawTransactionArgument<number>;
+    executionPrice: TransactionArgument;
+    collateralPrice: TransactionArgument;
+}
+export interface CalculatePositionLeverageBpsOptions {
+    package?: string;
+    arguments: CalculatePositionLeverageBpsArguments | [
+        totalSize: TransactionArgument,
+        totalCollateralAmount: RawTransactionArgument<number | bigint>,
+        collateralDecimal: RawTransactionArgument<number>,
+        executionPrice: TransactionArgument,
+        collateralPrice: TransactionArgument
+    ];
+}
+export declare function calculatePositionLeverageBps(options: CalculatePositionLeverageBpsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasMinPositionCollateralValueArguments {
+    minCollateralValue: RawTransactionArgument<number | bigint>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+    collateralDecimal: RawTransactionArgument<number>;
+    collateralPrice: TransactionArgument;
+}
+export interface HasMinPositionCollateralValueOptions {
+    package?: string;
+    arguments: HasMinPositionCollateralValueArguments | [
+        minCollateralValue: RawTransactionArgument<number | bigint>,
+        collateralAmount: RawTransactionArgument<number | bigint>,
+        collateralDecimal: RawTransactionArgument<number>,
+        collateralPrice: TransactionArgument
+    ];
+}
+export declare function hasMinPositionCollateralValue(options: HasMinPositionCollateralValueOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertMinPositionCollateralValueArguments {
+    minCollateralValue: RawTransactionArgument<number | bigint>;
+    collateralAmount: RawTransactionArgument<number | bigint>;
+    collateralDecimal: RawTransactionArgument<number>;
+    collateralPrice: TransactionArgument;
+}
+export interface AssertMinPositionCollateralValueOptions {
+    package?: string;
+    arguments: AssertMinPositionCollateralValueArguments | [
+        minCollateralValue: RawTransactionArgument<number | bigint>,
+        collateralAmount: RawTransactionArgument<number | bigint>,
+        collateralDecimal: RawTransactionArgument<number>,
+        collateralPrice: TransactionArgument
+    ];
+}
+export declare function assertMinPositionCollateralValue(options: AssertMinPositionCollateralValueOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ProportionalAmountArguments {
+    total: RawTransactionArgument<number | bigint>;
+    partial: TransactionArgument;
+    base: TransactionArgument;
+}
+export interface ProportionalAmountOptions {
+    package?: string;
+    arguments: ProportionalAmountArguments | [
+        total: RawTransactionArgument<number | bigint>,
+        partial: TransactionArgument,
+        base: TransactionArgument
+    ];
+}
+export declare function proportionalAmount(options: ProportionalAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DebitCollateralAmountArguments {
+    remaining: RawTransactionArgument<number | bigint>;
+    deficit: RawTransactionArgument<number | bigint>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface DebitCollateralAmountOptions {
+    package?: string;
+    arguments: DebitCollateralAmountArguments | [
+        remaining: RawTransactionArgument<number | bigint>,
+        deficit: RawTransactionArgument<number | bigint>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function debitCollateralAmount(options: DebitCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreditCollateralAmountArguments {
+    remaining: RawTransactionArgument<number | bigint>;
+    deficit: RawTransactionArgument<number | bigint>;
+    amount: RawTransactionArgument<number | bigint>;
+}
+export interface CreditCollateralAmountOptions {
+    package?: string;
+    arguments: CreditCollateralAmountArguments | [
+        remaining: RawTransactionArgument<number | bigint>,
+        deficit: RawTransactionArgument<number | bigint>,
+        amount: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function creditCollateralAmount(options: CreditCollateralAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CalculateRemainingCollateralAfterPartialReduceArguments {
+    position: RawTransactionArgument<string>;
+    reduceSize: TransactionArgument;
+    closeFee: RawTransactionArgument<number | bigint>;
+    currentPrice: TransactionArgument;
+    collateralPrice: TransactionArgument;
+    addedCollateralAmount: RawTransactionArgument<number | bigint>;
+}
+export interface CalculateRemainingCollateralAfterPartialReduceOptions {
+    package?: string;
+    arguments: CalculateRemainingCollateralAfterPartialReduceArguments | [
+        position: RawTransactionArgument<string>,
+        reduceSize: TransactionArgument,
+        closeFee: RawTransactionArgument<number | bigint>,
+        currentPrice: TransactionArgument,
+        collateralPrice: TransactionArgument,
+        addedCollateralAmount: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function calculateRemainingCollateralAfterPartialReduce(options: CalculateRemainingCollateralAfterPartialReduceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CanPositionGrowArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    isLong: RawTransactionArgument<boolean>;
+    currentSize: TransactionArgument;
+    addedSize: TransactionArgument;
+    effectiveCollateralAmount: RawTransactionArgument<number | bigint>;
+    collateralDecimal: RawTransactionArgument<number>;
+    collateralToken: TransactionArgument;
+    executionPrice: TransactionArgument;
+    collateralPrice: TransactionArgument;
+}
+export interface CanPositionGrowOptions {
+    package?: string;
+    arguments: CanPositionGrowArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        isLong: RawTransactionArgument<boolean>,
+        currentSize: TransactionArgument,
+        addedSize: TransactionArgument,
+        effectiveCollateralAmount: RawTransactionArgument<number | bigint>,
+        collateralDecimal: RawTransactionArgument<number>,
+        collateralToken: TransactionArgument,
+        executionPrice: TransactionArgument,
+        collateralPrice: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Non-aborting growth check used by keeper order matching. Invalid standalone
+ * orders are rotated behind valid orders at the same trigger price.
+ */
+export declare function canPositionGrow(options: CanPositionGrowOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ValidatePositionGrowthArguments {
+    globalConfig: RawTransactionArgument<string>;
+    marketConfig: RawTransactionArgument<string>;
+    pool: RawTransactionArgument<string>;
+    isLong: RawTransactionArgument<boolean>;
+    currentSize: TransactionArgument;
+    addedSize: TransactionArgument;
+    effectiveCollateralAmount: RawTransactionArgument<number | bigint>;
+    collateralDecimal: RawTransactionArgument<number>;
+    collateralToken: TransactionArgument;
+    executionPrice: TransactionArgument;
+    collateralPrice: TransactionArgument;
+}
+export interface ValidatePositionGrowthOptions {
+    package?: string;
+    arguments: ValidatePositionGrowthArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        marketConfig: RawTransactionArgument<string>,
+        pool: RawTransactionArgument<string>,
+        isLong: RawTransactionArgument<boolean>,
+        currentSize: TransactionArgument,
+        addedSize: TransactionArgument,
+        effectiveCollateralAmount: RawTransactionArgument<number | bigint>,
+        collateralDecimal: RawTransactionArgument<number>,
+        collateralToken: TransactionArgument,
+        executionPrice: TransactionArgument,
+        collateralPrice: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function validatePositionGrowth(options: ValidatePositionGrowthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WeightedAveragePriceArguments {
+    currentSize: TransactionArgument;
+    currentAveragePrice: TransactionArgument;
+    addSize: TransactionArgument;
+    fillPrice: TransactionArgument;
+}
+export interface WeightedAveragePriceOptions {
+    package?: string;
+    arguments: WeightedAveragePriceArguments | [
+        currentSize: TransactionArgument,
+        currentAveragePrice: TransactionArgument,
+        addSize: TransactionArgument,
+        fillPrice: TransactionArgument
+    ];
+}
+export declare function weightedAveragePrice(options: WeightedAveragePriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NormalizeTriggerPriceArguments {
+    triggerPrice: TransactionArgument;
+    orderPriceTick: TransactionArgument;
+}
+export interface NormalizeTriggerPriceOptions {
+    package?: string;
+    arguments: NormalizeTriggerPriceArguments | [
+        triggerPrice: TransactionArgument,
+        orderPriceTick: TransactionArgument
+    ];
+}
+export declare function normalizeTriggerPrice(options: NormalizeTriggerPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasPendingPreOrdersArguments {
+    market: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+}
+export interface HasPendingPreOrdersOptions {
+    package?: string;
+    arguments: HasPendingPreOrdersArguments | [
+        market: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** View: whether `main_order_id` has reserved pre-orders pending in `market`. */
+export declare function hasPendingPreOrders(options: HasPendingPreOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PendingPreOrdersCountArguments {
+    market: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+}
+export interface PendingPreOrdersCountOptions {
+    package?: string;
+    arguments: PendingPreOrdersCountArguments | [
+        market: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * View: how many pre-orders are reserved against `main_order_id`. `0` if no entry
+ * exists.
+ */
+export declare function pendingPreOrdersCount(options: PendingPreOrdersCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReservePreOrdersArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    collateralDecimal: RawTransactionArgument<number>;
+    preOrders: TransactionArgument;
+}
+export interface ReservePreOrdersOptions {
+    package?: string;
+    arguments: ReservePreOrdersArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        collateralDecimal: RawTransactionArgument<number>,
+        preOrders: TransactionArgument
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Mints fresh order ids for every `PlaceOrderArgument` in `pre_orders`, builds a
+ * real `Order` per entry (reduce-only, zero-collateral,
+ * `linked_position_id = None`), stashes each one in `pending_pre_orders` under its
+ * own id, and records the id list in `pending_pre_order_index` under
+ * `main_order_id` — appending to any existing entry so this helper also works for
+ * the per-leg `add_pre_order` path. Emits one `PreOrderCreated` per reserved
+ * pre-order. No-op when `pre_orders` is empty.
+ */
+export declare function reservePreOrders(options: ReservePreOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DropPendingPreOrdersIfExistsArguments {
+    globalConfig: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+}
+export interface DropPendingPreOrdersIfExistsOptions {
+    package?: string;
+    arguments: DropPendingPreOrdersIfExistsArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        mainOrderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Drops every pre-order reserved against `main_order_id` (if any), destroying each
+ * via `position::remove_order` (which splits the zero collateral back into the
+ * vault and deletes the order UID) and emitting one `PreOrderCancelled` per
+ * dropped pre-order.
+ */
+export declare function dropPendingPreOrdersIfExists(options: DropPendingPreOrdersIfExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ActivatePendingPreOrdersArguments {
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    pos: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    mainOrderId: RawTransactionArgument<number | bigint>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    marketId: RawTransactionArgument<string>;
+}
+export interface ActivatePendingPreOrdersOptions {
+    package?: string;
+    arguments: ActivatePendingPreOrdersArguments | [
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        pos: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        mainOrderId: RawTransactionArgument<number | bigint>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        marketId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Promotes reserved pre-orders to real reduce-only linked orders on the freshly
+ * opened position. Called from the standalone-fill branch of `match_orders` right
+ * before the new position is pushed to the market. Each reserved `Order` was
+ * created at place time with `linked_position_id = None`; here we stamp in the new
+ * `position_id` and move the order onto the live book.
+ */
+export declare function activatePendingPreOrders(options: ActivatePendingPreOrdersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertPositionOwnerArguments {
+    position: RawTransactionArgument<string>;
+    accountObjectAddress: RawTransactionArgument<string>;
+}
+export interface AssertPositionOwnerOptions {
+    package?: string;
+    arguments: AssertPositionOwnerArguments | [
+        position: RawTransactionArgument<string>,
+        accountObjectAddress: RawTransactionArgument<string>
+    ];
+}
+export declare function assertPositionOwner(options: AssertPositionOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertPositionCollateralTypeArguments {
+    position: RawTransactionArgument<string>;
+}
+export interface AssertPositionCollateralTypeOptions {
+    package?: string;
+    arguments: AssertPositionCollateralTypeArguments | [
+        position: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function assertPositionCollateralType(options: AssertPositionCollateralTypeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowOwnedPositionArguments {
+    market: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    accountObjectAddress: RawTransactionArgument<string>;
+}
+export interface BorrowOwnedPositionOptions {
+    package?: string;
+    arguments: BorrowOwnedPositionArguments | [
+        market: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        accountObjectAddress: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowOwnedPosition(options: BorrowOwnedPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowOwnedPositionMutArguments {
+    market: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    accountObjectAddress: RawTransactionArgument<string>;
+}
+export interface BorrowOwnedPositionMutOptions {
+    package?: string;
+    arguments: BorrowOwnedPositionMutArguments | [
+        market: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        accountObjectAddress: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowOwnedPositionMut(options: BorrowOwnedPositionMutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TakeOwnedPositionArguments {
+    market: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+    accountObjectAddress: RawTransactionArgument<string>;
+    now: RawTransactionArgument<number | bigint>;
+    requireCooldown: RawTransactionArgument<boolean>;
+}
+export interface TakeOwnedPositionOptions {
+    package?: string;
+    arguments: TakeOwnedPositionArguments | [
+        market: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>,
+        accountObjectAddress: RawTransactionArgument<string>,
+        now: RawTransactionArgument<number | bigint>,
+        requireCooldown: RawTransactionArgument<boolean>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function takeOwnedPosition(options: TakeOwnedPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FindOrderTypeTagArguments {
+    market: RawTransactionArgument<string>;
+    triggerPriceKey: RawTransactionArgument<number | bigint>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface FindOrderTypeTagOptions {
+    package?: string;
+    arguments: FindOrderTypeTagArguments | [
+        market: RawTransactionArgument<string>,
+        triggerPriceKey: RawTransactionArgument<number | bigint>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function findOrderTypeTag(options: FindOrderTypeTagOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FindCancelOrderLocationArguments {
+    market: RawTransactionArgument<string>;
+    orderTypeTag: RawTransactionArgument<number>;
+    triggerPrice: RawTransactionArgument<number | bigint>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface FindCancelOrderLocationOptions {
+    package?: string;
+    arguments: FindCancelOrderLocationArguments | [
+        market: RawTransactionArgument<string>,
+        orderTypeTag: RawTransactionArgument<number>,
+        triggerPrice: RawTransactionArgument<number | bigint>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function findCancelOrderLocation(options: FindCancelOrderLocationOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FindOrderLocationByIdArguments {
+    market: RawTransactionArgument<string>;
+    orderTypeTag: RawTransactionArgument<number>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface FindOrderLocationByIdOptions {
+    package?: string;
+    arguments: FindOrderLocationByIdArguments | [
+        market: RawTransactionArgument<string>,
+        orderTypeTag: RawTransactionArgument<number>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function findOrderLocationById(options: FindOrderLocationByIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FindOrderPriceKeyInBookArguments {
+    book: TransactionArgument;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface FindOrderPriceKeyInBookOptions {
+    package?: string;
+    arguments: FindOrderPriceKeyInBookArguments | [
+        book: TransactionArgument,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function findOrderPriceKeyInBook(options: FindOrderPriceKeyInBookOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LevelContainsOrderArguments {
+    level: TransactionArgument;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface LevelContainsOrderOptions {
+    package?: string;
+    arguments: LevelContainsOrderArguments | [
+        level: TransactionArgument,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function levelContainsOrder(options: LevelContainsOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasOrderInBookArguments {
+    book: TransactionArgument;
+    priceKey: RawTransactionArgument<number | bigint>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface HasOrderInBookOptions {
+    package?: string;
+    arguments: HasOrderInBookArguments | [
+        book: TransactionArgument,
+        priceKey: RawTransactionArgument<number | bigint>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function hasOrderInBook(options: HasOrderInBookOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TakeLinkedOrderAtKeyArguments {
+    market: RawTransactionArgument<string>;
+    triggerPriceKey: RawTransactionArgument<number | bigint>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface TakeLinkedOrderAtKeyOptions {
+    package?: string;
+    arguments: TakeLinkedOrderAtKeyArguments | [
+        market: RawTransactionArgument<string>,
+        triggerPriceKey: RawTransactionArgument<number | bigint>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function takeLinkedOrderAtKey(options: TakeLinkedOrderAtKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CancelLinkedOrdersToBalanceArguments {
+    globalConfig: RawTransactionArgument<string>;
+    wxaRegistry: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    linkedOrderIds: RawTransactionArgument<Array<number | bigint>>;
+    linkedOrderPriceKeys: RawTransactionArgument<Array<number | bigint>>;
+    memoCode: RawTransactionArgument<number>;
+}
+export interface CancelLinkedOrdersToBalanceOptions {
+    package?: string;
+    arguments: CancelLinkedOrdersToBalanceArguments | [
+        globalConfig: RawTransactionArgument<string>,
+        wxaRegistry: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        linkedOrderIds: RawTransactionArgument<Array<number | bigint>>,
+        linkedOrderPriceKeys: RawTransactionArgument<Array<number | bigint>>,
+        memoCode: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function cancelLinkedOrdersToBalance(options: CancelLinkedOrdersToBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMutOrderBookArguments {
+    market: RawTransactionArgument<string>;
+    tag: RawTransactionArgument<number>;
+}
+export interface BorrowMutOrderBookOptions {
+    package?: string;
+    arguments: BorrowMutOrderBookArguments | [
+        market: RawTransactionArgument<string>,
+        tag: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function borrowMutOrderBook(options: BorrowMutOrderBookOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TakeOrderDirectArguments {
+    market: RawTransactionArgument<string>;
+    triggerPriceKey: RawTransactionArgument<number | bigint>;
+    orderId: RawTransactionArgument<number | bigint>;
+    user: RawTransactionArgument<string>;
+    orderTypeTag: RawTransactionArgument<number>;
+}
+export interface TakeOrderDirectOptions {
+    package?: string;
+    arguments: TakeOrderDirectArguments | [
+        market: RawTransactionArgument<string>,
+        triggerPriceKey: RawTransactionArgument<number | bigint>,
+        orderId: RawTransactionArgument<number | bigint>,
+        user: RawTransactionArgument<string>,
+        orderTypeTag: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function takeOrderDirect(options: TakeOrderDirectOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReturnToUserArguments {
+    wxaRegistry: RawTransactionArgument<string>;
+    balance: TransactionArgument;
+    accountObjAddr: RawTransactionArgument<string>;
+}
+export interface ReturnToUserOptions {
+    package?: string;
+    arguments: ReturnToUserArguments | [
+        wxaRegistry: RawTransactionArgument<string>,
+        balance: TransactionArgument,
+        accountObjAddr: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Returns `balance` to the user's wxa stored balance under the `WaterXPerp`
+ * witness. `account_obj_addr` is the wxa account's UID address (i.e.
+ * `account_id.to_address()`), so `.to_id()` recovers the account_id. Zero balances
+ * are silently destroyed (no event).
+ */
+export declare function returnToUser(options: ReturnToUserOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketIdArguments {
+    market: RawTransactionArgument<string>;
+}
+export interface MarketIdOptions {
+    package?: string;
+    arguments: MarketIdArguments | [
+        market: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns the object ID of this Market (trading vault). */
+export declare function marketId(options: MarketIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowPositionArguments {
+    market: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowPositionOptions {
+    package?: string;
+    arguments: BorrowPositionArguments | [
+        market: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Borrows a position by ID. */
+export declare function borrowPosition(options: BorrowPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasPositionArguments {
+    market: RawTransactionArgument<string>;
+    positionId: RawTransactionArgument<number | bigint>;
+}
+export interface HasPositionOptions {
+    package?: string;
+    arguments: HasPositionArguments | [
+        market: RawTransactionArgument<string>,
+        positionId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Checks if a position exists. */
+export declare function hasPosition(options: HasPositionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowOrderArguments {
+    market: RawTransactionArgument<string>;
+    orderTypeTag: RawTransactionArgument<number>;
+    triggerPriceKey: RawTransactionArgument<number | bigint>;
+    orderId: RawTransactionArgument<number | bigint>;
+}
+export interface BorrowOrderOptions {
+    package?: string;
+    arguments: BorrowOrderArguments | [
+        market: RawTransactionArgument<string>,
+        orderTypeTag: RawTransactionArgument<number>,
+        triggerPriceKey: RawTransactionArgument<number | bigint>,
+        orderId: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Borrows a single order by type, price key, and order id. */
+export declare function borrowOrder(options: BorrowOrderOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowPositionsArguments {
+    market: RawTransactionArgument<string>;
+}
+export interface BorrowPositionsOptions {
+    package?: string;
+    arguments: BorrowPositionsArguments | [
+        market: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Borrows the positions KeyedBigVector (for paginated iteration). */
+export declare function borrowPositions(options: BorrowPositionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowOrderBookArguments {
+    market: RawTransactionArgument<string>;
+    orderTypeTag: RawTransactionArgument<number>;
+}
+export interface BorrowOrderBookOptions {
+    package?: string;
+    arguments: BorrowOrderBookArguments | [
+        market: RawTransactionArgument<string>,
+        orderTypeTag: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Borrows an order book by type tag (0-3), read-only. */
+export declare function borrowOrderBook(options: BorrowOrderBookOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowConfigArguments {
+    market: RawTransactionArgument<string>;
+}
+export interface BorrowConfigOptions {
+    package?: string;
+    arguments: BorrowConfigArguments | [
+        market: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Borrows the market config (for view.move). */
+export declare function borrowConfig(options: BorrowConfigOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MarketSymbolArguments {
+    market: RawTransactionArgument<string>;
+}
+export interface MarketSymbolOptions {
+    package?: string;
+    arguments: MarketSymbolArguments | [
+        market: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function marketSymbol(options: MarketSymbolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateMarketRegistryArguments {
+    Cap: RawTransactionArgument<string>;
+}
+export interface CreateMarketRegistryOptions {
+    package?: string;
+    arguments: CreateMarketRegistryArguments | [
+        Cap: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Creates and shares a new `MarketRegistry`. Admin-gated. */
+export declare function createMarketRegistry(options: CreateMarketRegistryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegistryAssertVersionArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface RegistryAssertVersionOptions {
+    package?: string;
+    arguments: RegistryAssertVersionArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function registryAssertVersion(options: RegistryAssertVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegistryAllowVersionArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface RegistryAllowVersionOptions {
+    package?: string;
+    arguments: RegistryAllowVersionArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function registryAllowVersion(options: RegistryAllowVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegistryDisallowVersionArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface RegistryDisallowVersionOptions {
+    package?: string;
+    arguments: RegistryDisallowVersionArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function registryDisallowVersion(options: RegistryDisallowVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddMarketArguments {
+    registry: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    market: RawTransactionArgument<string>;
+}
+export interface AddMarketOptions {
+    package?: string;
+    arguments: AddMarketArguments | [
+        registry: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        market: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Stores `market` in the registry under `ticker`. Aborts if already taken. */
+export declare function addMarket(options: AddMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveMarketArguments {
+    registry: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface RemoveMarketOptions {
+    package?: string;
+    arguments: RemoveMarketArguments | [
+        registry: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Removes a market from the registry and returns it. */
+export declare function removeMarket(options: RemoveMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasMarketArguments {
+    registry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface HasMarketOptions {
+    package?: string;
+    arguments: HasMarketArguments | [
+        registry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function hasMarket(options: HasMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ListedTickersArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface ListedTickersOptions {
+    package?: string;
+    arguments: ListedTickersArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function listedTickers(options: ListedTickersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMarketArguments {
+    registry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface BorrowMarketOptions {
+    package?: string;
+    arguments: BorrowMarketArguments | [
+        registry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function borrowMarket(options: BorrowMarketOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMarketMutArguments {
+    registry: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface BorrowMarketMutOptions {
+    package?: string;
+    arguments: BorrowMarketMutArguments | [
+        registry: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function borrowMarketMut(options: BorrowMarketMutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;