@typus/typus-sdk 1.2.588 → 1.3.1

package/lib/utils/typus_perp/trading/structs.d.ts

@@ -0,0 +1,2305 @@
+import * as reified from "../../_framework/reified";
+import { Option } from "../../_dependencies/source/0x1/option/structs";
+import { TypeName } from "../../_dependencies/source/0x1/type-name/structs";
+import { ObjectTable } from "../../_dependencies/source/0x2/object-table/structs";
+import { UID } from "../../_dependencies/source/0x2/object/structs";
+import { Table } from "../../_dependencies/source/0x2/table/structs";
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr, Vector, ToTypeStr as ToPhantom } from "../../_framework/reified";
+import { FieldsWithTypes } from "../../_framework/util";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+export declare function isAddTradingSymbolEvent(type: string): boolean;
+export interface AddTradingSymbolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    baseTokenType: ToField<TypeName>;
+    marketInfo: ToField<MarketInfo>;
+    marketConfig: ToField<MarketConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type AddTradingSymbolEventReified = Reified<AddTradingSymbolEvent, AddTradingSymbolEventFields>;
+export declare class AddTradingSymbolEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::AddTradingSymbolEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::AddTradingSymbolEvent";
+    readonly $fullTypeName: "0x0::trading::AddTradingSymbolEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly baseTokenType: ToField<TypeName>;
+    readonly marketInfo: ToField<MarketInfo>;
+    readonly marketConfig: ToField<MarketConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): AddTradingSymbolEventReified;
+    static get r(): reified.StructClassReified<AddTradingSymbolEvent, AddTradingSymbolEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<AddTradingSymbolEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::AddTradingSymbolEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        base_token_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        market_info: {
+            is_active: boolean;
+            size_decimal: string;
+            user_position_side: boolean;
+            position_size: string;
+            next_position_id: string;
+            open_order_side: boolean;
+            open_order_size: string;
+            next_order_id: string;
+            u64_padding: string[];
+        };
+        market_config: {
+            oracle_id: string;
+            max_leverage_pct: string;
+            min_size: string;
+            lot_size: string;
+            trading_fee_rate: string;
+            trading_fee_decimal: string;
+            u64_padding: string[];
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        base_token_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        market_info: {
+            is_active: boolean;
+            size_decimal: string | number | bigint;
+            user_position_side: boolean;
+            position_size: string | number | bigint;
+            next_position_id: string | number | bigint;
+            open_order_side: boolean;
+            open_order_size: string | number | bigint;
+            next_order_id: string | number | bigint;
+            u64_padding: Iterable<string | number | bigint> & {
+                length: number;
+            };
+        };
+        market_config: {
+            oracle_id: string;
+            max_leverage_pct: string | number | bigint;
+            min_size: string | number | bigint;
+            lot_size: string | number | bigint;
+            trading_fee_rate: string | number | bigint;
+            trading_fee_decimal: string | number | bigint;
+            u64_padding: Iterable<string | number | bigint> & {
+                length: number;
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): AddTradingSymbolEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): AddTradingSymbolEvent;
+    static fromBcs(data: Uint8Array): AddTradingSymbolEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        baseTokenType: {
+            name: string;
+        };
+        marketInfo: {
+            isActive: boolean;
+            sizeDecimal: string;
+            userPositionSide: boolean;
+            positionSize: string;
+            nextPositionId: string;
+            openOrderSide: boolean;
+            openOrderSize: string;
+            nextOrderId: string;
+            u64Padding: string[];
+        };
+        marketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        baseTokenType: {
+            name: string;
+        };
+        marketInfo: {
+            isActive: boolean;
+            sizeDecimal: string;
+            userPositionSide: boolean;
+            positionSize: string;
+            nextPositionId: string;
+            openOrderSide: boolean;
+            openOrderSize: string;
+            nextOrderId: string;
+            u64Padding: string[];
+        };
+        marketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): AddTradingSymbolEvent;
+    static fromJSON(json: Record<string, any>): AddTradingSymbolEvent;
+    static fromSuiParsedData(content: SuiParsedData): AddTradingSymbolEvent;
+    static fetch(client: SuiClient, id: string): Promise<AddTradingSymbolEvent>;
+}
+export declare function isCancelTradingOrderEvent(type: string): boolean;
+export interface CancelTradingOrderEventFields {
+    sender: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    orderId: ToField<"u64">;
+    triggerPrice: ToField<Option<"u64">>;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    releasedCollateralAmount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type CancelTradingOrderEventReified = Reified<CancelTradingOrderEvent, CancelTradingOrderEventFields>;
+export declare class CancelTradingOrderEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::CancelTradingOrderEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::CancelTradingOrderEvent";
+    readonly $fullTypeName: "0x0::trading::CancelTradingOrderEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly orderId: ToField<"u64">;
+    readonly triggerPrice: ToField<Option<"u64">>;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly releasedCollateralAmount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): CancelTradingOrderEventReified;
+    static get r(): reified.StructClassReified<CancelTradingOrderEvent, CancelTradingOrderEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<CancelTradingOrderEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::CancelTradingOrderEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        market_index: string;
+        order_id: string;
+        trigger_price: {
+            vec: any[];
+        };
+        collateral_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        released_collateral_amount: string;
+        u64_padding: string[];
+    }, {
+        sender: string;
+        market_index: string | number | bigint;
+        order_id: string | number | bigint;
+        trigger_price: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        collateral_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        released_collateral_amount: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): CancelTradingOrderEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): CancelTradingOrderEvent;
+    static fromBcs(data: Uint8Array): CancelTradingOrderEvent;
+    toJSONField(): {
+        sender: string;
+        marketIndex: string;
+        orderId: string;
+        triggerPrice: string | null;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        releasedCollateralAmount: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        marketIndex: string;
+        orderId: string;
+        triggerPrice: string | null;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        releasedCollateralAmount: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): CancelTradingOrderEvent;
+    static fromJSON(json: Record<string, any>): CancelTradingOrderEvent;
+    static fromSuiParsedData(content: SuiParsedData): CancelTradingOrderEvent;
+    static fetch(client: SuiClient, id: string): Promise<CancelTradingOrderEvent>;
+}
+export declare function isCancelTradingOrderWithBidReceiptsEvent(type: string): boolean;
+export interface CancelTradingOrderWithBidReceiptsEventFields {
+    sender: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    orderId: ToField<"u64">;
+    triggerPrice: ToField<Option<"u64">>;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    returnedReceipts: ToField<Vector<"address">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type CancelTradingOrderWithBidReceiptsEventReified = Reified<CancelTradingOrderWithBidReceiptsEvent, CancelTradingOrderWithBidReceiptsEventFields>;
+export declare class CancelTradingOrderWithBidReceiptsEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::CancelTradingOrderWithBidReceiptsEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::CancelTradingOrderWithBidReceiptsEvent";
+    readonly $fullTypeName: "0x0::trading::CancelTradingOrderWithBidReceiptsEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly orderId: ToField<"u64">;
+    readonly triggerPrice: ToField<Option<"u64">>;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly returnedReceipts: ToField<Vector<"address">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): CancelTradingOrderWithBidReceiptsEventReified;
+    static get r(): reified.StructClassReified<CancelTradingOrderWithBidReceiptsEvent, CancelTradingOrderWithBidReceiptsEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<CancelTradingOrderWithBidReceiptsEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::CancelTradingOrderWithBidReceiptsEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        market_index: string;
+        order_id: string;
+        trigger_price: {
+            vec: any[];
+        };
+        collateral_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        returned_receipts: string[];
+        u64_padding: string[];
+    }, {
+        sender: string;
+        market_index: string | number | bigint;
+        order_id: string | number | bigint;
+        trigger_price: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        collateral_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        returned_receipts: Iterable<string> & {
+            length: number;
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): CancelTradingOrderWithBidReceiptsEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): CancelTradingOrderWithBidReceiptsEvent;
+    static fromBcs(data: Uint8Array): CancelTradingOrderWithBidReceiptsEvent;
+    toJSONField(): {
+        sender: string;
+        marketIndex: string;
+        orderId: string;
+        triggerPrice: string | null;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        returnedReceipts: string[];
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        marketIndex: string;
+        orderId: string;
+        triggerPrice: string | null;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        returnedReceipts: string[];
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): CancelTradingOrderWithBidReceiptsEvent;
+    static fromJSON(json: Record<string, any>): CancelTradingOrderWithBidReceiptsEvent;
+    static fromSuiParsedData(content: SuiParsedData): CancelTradingOrderWithBidReceiptsEvent;
+    static fetch(client: SuiClient, id: string): Promise<CancelTradingOrderWithBidReceiptsEvent>;
+}
+export declare function isCreateTradingOrderEvent(type: string): boolean;
+export interface CreateTradingOrderEventFields {
+    sender: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    poolIndex: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    linkedPositionId: ToField<Option<"u64">>;
+    collateralAmount: ToField<"u64">;
+    leveragePct: ToField<"u64">;
+    reduceOnly: ToField<"bool">;
+    isLong: ToField<"bool">;
+    isStopOrder: ToField<"bool">;
+    size: ToField<"u64">;
+    triggerPrice: ToField<"u64">;
+    filled: ToField<"bool">;
+    filledPrice: ToField<Option<"u64">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type CreateTradingOrderEventReified = Reified<CreateTradingOrderEvent, CreateTradingOrderEventFields>;
+export declare class CreateTradingOrderEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::CreateTradingOrderEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::CreateTradingOrderEvent";
+    readonly $fullTypeName: "0x0::trading::CreateTradingOrderEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly poolIndex: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly linkedPositionId: ToField<Option<"u64">>;
+    readonly collateralAmount: ToField<"u64">;
+    readonly leveragePct: ToField<"u64">;
+    readonly reduceOnly: ToField<"bool">;
+    readonly isLong: ToField<"bool">;
+    readonly isStopOrder: ToField<"bool">;
+    readonly size: ToField<"u64">;
+    readonly triggerPrice: ToField<"u64">;
+    readonly filled: ToField<"bool">;
+    readonly filledPrice: ToField<Option<"u64">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): CreateTradingOrderEventReified;
+    static get r(): reified.StructClassReified<CreateTradingOrderEvent, CreateTradingOrderEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<CreateTradingOrderEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::CreateTradingOrderEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        market_index: string;
+        pool_index: string;
+        collateral_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        linked_position_id: {
+            vec: any[];
+        };
+        collateral_amount: string;
+        leverage_pct: string;
+        reduce_only: boolean;
+        is_long: boolean;
+        is_stop_order: boolean;
+        size: string;
+        trigger_price: string;
+        filled: boolean;
+        filled_price: {
+            vec: any[];
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        market_index: string | number | bigint;
+        pool_index: string | number | bigint;
+        collateral_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        linked_position_id: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        collateral_amount: string | number | bigint;
+        leverage_pct: string | number | bigint;
+        reduce_only: boolean;
+        is_long: boolean;
+        is_stop_order: boolean;
+        size: string | number | bigint;
+        trigger_price: string | number | bigint;
+        filled: boolean;
+        filled_price: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): CreateTradingOrderEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): CreateTradingOrderEvent;
+    static fromBcs(data: Uint8Array): CreateTradingOrderEvent;
+    toJSONField(): {
+        sender: string;
+        marketIndex: string;
+        poolIndex: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        linkedPositionId: string | null;
+        collateralAmount: string;
+        leveragePct: string;
+        reduceOnly: boolean;
+        isLong: boolean;
+        isStopOrder: boolean;
+        size: string;
+        triggerPrice: string;
+        filled: boolean;
+        filledPrice: string | null;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        marketIndex: string;
+        poolIndex: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        linkedPositionId: string | null;
+        collateralAmount: string;
+        leveragePct: string;
+        reduceOnly: boolean;
+        isLong: boolean;
+        isStopOrder: boolean;
+        size: string;
+        triggerPrice: string;
+        filled: boolean;
+        filledPrice: string | null;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): CreateTradingOrderEvent;
+    static fromJSON(json: Record<string, any>): CreateTradingOrderEvent;
+    static fromSuiParsedData(content: SuiParsedData): CreateTradingOrderEvent;
+    static fetch(client: SuiClient, id: string): Promise<CreateTradingOrderEvent>;
+}
+export declare function isCreateTradingOrderWithBidReceiptsEvent(type: string): boolean;
+export interface CreateTradingOrderWithBidReceiptsEventFields {
+    sender: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    poolIndex: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    collateralInDepositToken: ToField<"u64">;
+    leveragePct: ToField<"u64">;
+    reduceOnly: ToField<"bool">;
+    isLong: ToField<"bool">;
+    isStopOrder: ToField<"bool">;
+    size: ToField<"u64">;
+    triggerPrice: ToField<"u64">;
+    filled: ToField<"bool">;
+    filledPrice: ToField<Option<"u64">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type CreateTradingOrderWithBidReceiptsEventReified = Reified<CreateTradingOrderWithBidReceiptsEvent, CreateTradingOrderWithBidReceiptsEventFields>;
+export declare class CreateTradingOrderWithBidReceiptsEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::CreateTradingOrderWithBidReceiptsEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::CreateTradingOrderWithBidReceiptsEvent";
+    readonly $fullTypeName: "0x0::trading::CreateTradingOrderWithBidReceiptsEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly poolIndex: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly collateralInDepositToken: ToField<"u64">;
+    readonly leveragePct: ToField<"u64">;
+    readonly reduceOnly: ToField<"bool">;
+    readonly isLong: ToField<"bool">;
+    readonly isStopOrder: ToField<"bool">;
+    readonly size: ToField<"u64">;
+    readonly triggerPrice: ToField<"u64">;
+    readonly filled: ToField<"bool">;
+    readonly filledPrice: ToField<Option<"u64">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): CreateTradingOrderWithBidReceiptsEventReified;
+    static get r(): reified.StructClassReified<CreateTradingOrderWithBidReceiptsEvent, CreateTradingOrderWithBidReceiptsEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<CreateTradingOrderWithBidReceiptsEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::CreateTradingOrderWithBidReceiptsEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        market_index: string;
+        pool_index: string;
+        collateral_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        collateral_in_deposit_token: string;
+        leverage_pct: string;
+        reduce_only: boolean;
+        is_long: boolean;
+        is_stop_order: boolean;
+        size: string;
+        trigger_price: string;
+        filled: boolean;
+        filled_price: {
+            vec: any[];
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        market_index: string | number | bigint;
+        pool_index: string | number | bigint;
+        collateral_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        collateral_in_deposit_token: string | number | bigint;
+        leverage_pct: string | number | bigint;
+        reduce_only: boolean;
+        is_long: boolean;
+        is_stop_order: boolean;
+        size: string | number | bigint;
+        trigger_price: string | number | bigint;
+        filled: boolean;
+        filled_price: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): CreateTradingOrderWithBidReceiptsEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): CreateTradingOrderWithBidReceiptsEvent;
+    static fromBcs(data: Uint8Array): CreateTradingOrderWithBidReceiptsEvent;
+    toJSONField(): {
+        sender: string;
+        marketIndex: string;
+        poolIndex: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        collateralInDepositToken: string;
+        leveragePct: string;
+        reduceOnly: boolean;
+        isLong: boolean;
+        isStopOrder: boolean;
+        size: string;
+        triggerPrice: string;
+        filled: boolean;
+        filledPrice: string | null;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        marketIndex: string;
+        poolIndex: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        collateralInDepositToken: string;
+        leveragePct: string;
+        reduceOnly: boolean;
+        isLong: boolean;
+        isStopOrder: boolean;
+        size: string;
+        triggerPrice: string;
+        filled: boolean;
+        filledPrice: string | null;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): CreateTradingOrderWithBidReceiptsEvent;
+    static fromJSON(json: Record<string, any>): CreateTradingOrderWithBidReceiptsEvent;
+    static fromSuiParsedData(content: SuiParsedData): CreateTradingOrderWithBidReceiptsEvent;
+    static fetch(client: SuiClient, id: string): Promise<CreateTradingOrderWithBidReceiptsEvent>;
+}
+export declare function isLiquidateEvent(type: string): boolean;
+export interface LiquidateEventFields {
+    sender: ToField<"address">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    positionId: ToField<"u64">;
+    collateralPrice: ToField<"u64">;
+    tradingPrice: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type LiquidateEventReified = Reified<LiquidateEvent, LiquidateEventFields>;
+export declare class LiquidateEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::LiquidateEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::LiquidateEvent";
+    readonly $fullTypeName: "0x0::trading::LiquidateEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly positionId: ToField<"u64">;
+    readonly collateralPrice: ToField<"u64">;
+    readonly tradingPrice: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): LiquidateEventReified;
+    static get r(): reified.StructClassReified<LiquidateEvent, LiquidateEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<LiquidateEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::LiquidateEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        collateral_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        position_id: string;
+        collateral_price: string;
+        trading_price: string;
+        u64_padding: string[];
+    }, {
+        sender: string;
+        collateral_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        position_id: string | number | bigint;
+        collateral_price: string | number | bigint;
+        trading_price: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): LiquidateEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): LiquidateEvent;
+    static fromBcs(data: Uint8Array): LiquidateEvent;
+    toJSONField(): {
+        sender: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        positionId: string;
+        collateralPrice: string;
+        tradingPrice: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        positionId: string;
+        collateralPrice: string;
+        tradingPrice: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): LiquidateEvent;
+    static fromJSON(json: Record<string, any>): LiquidateEvent;
+    static fromSuiParsedData(content: SuiParsedData): LiquidateEvent;
+    static fetch(client: SuiClient, id: string): Promise<LiquidateEvent>;
+}
+export declare function isMarketConfig(type: string): boolean;
+export interface MarketConfigFields {
+    oracleId: ToField<"address">;
+    maxLeveragePct: ToField<"u64">;
+    minSize: ToField<"u64">;
+    lotSize: ToField<"u64">;
+    tradingFeeRate: ToField<"u64">;
+    tradingFeeDecimal: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type MarketConfigReified = Reified<MarketConfig, MarketConfigFields>;
+export declare class MarketConfig implements StructClass {
+    static readonly $typeName = "0x0::trading::MarketConfig";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::MarketConfig";
+    readonly $fullTypeName: "0x0::trading::MarketConfig";
+    readonly $typeArgs: [];
+    readonly oracleId: ToField<"address">;
+    readonly maxLeveragePct: ToField<"u64">;
+    readonly minSize: ToField<"u64">;
+    readonly lotSize: ToField<"u64">;
+    readonly tradingFeeRate: ToField<"u64">;
+    readonly tradingFeeDecimal: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): MarketConfigReified;
+    static get r(): reified.StructClassReified<MarketConfig, MarketConfigFields>;
+    static phantom(): PhantomReified<ToTypeStr<MarketConfig>>;
+    static get p(): reified.PhantomReified<"0x0::trading::MarketConfig">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        oracle_id: string;
+        max_leverage_pct: string;
+        min_size: string;
+        lot_size: string;
+        trading_fee_rate: string;
+        trading_fee_decimal: string;
+        u64_padding: string[];
+    }, {
+        oracle_id: string;
+        max_leverage_pct: string | number | bigint;
+        min_size: string | number | bigint;
+        lot_size: string | number | bigint;
+        trading_fee_rate: string | number | bigint;
+        trading_fee_decimal: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): MarketConfig;
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarketConfig;
+    static fromBcs(data: Uint8Array): MarketConfig;
+    toJSONField(): {
+        oracleId: string;
+        maxLeveragePct: string;
+        minSize: string;
+        lotSize: string;
+        tradingFeeRate: string;
+        tradingFeeDecimal: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        oracleId: string;
+        maxLeveragePct: string;
+        minSize: string;
+        lotSize: string;
+        tradingFeeRate: string;
+        tradingFeeDecimal: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): MarketConfig;
+    static fromJSON(json: Record<string, any>): MarketConfig;
+    static fromSuiParsedData(content: SuiParsedData): MarketConfig;
+    static fetch(client: SuiClient, id: string): Promise<MarketConfig>;
+}
+export declare function isMarketInfo(type: string): boolean;
+export interface MarketInfoFields {
+    isActive: ToField<"bool">;
+    sizeDecimal: ToField<"u64">;
+    userPositionSide: ToField<"bool">;
+    positionSize: ToField<"u64">;
+    nextPositionId: ToField<"u64">;
+    openOrderSide: ToField<"bool">;
+    openOrderSize: ToField<"u64">;
+    nextOrderId: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type MarketInfoReified = Reified<MarketInfo, MarketInfoFields>;
+export declare class MarketInfo implements StructClass {
+    static readonly $typeName = "0x0::trading::MarketInfo";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::MarketInfo";
+    readonly $fullTypeName: "0x0::trading::MarketInfo";
+    readonly $typeArgs: [];
+    readonly isActive: ToField<"bool">;
+    readonly sizeDecimal: ToField<"u64">;
+    readonly userPositionSide: ToField<"bool">;
+    readonly positionSize: ToField<"u64">;
+    readonly nextPositionId: ToField<"u64">;
+    readonly openOrderSide: ToField<"bool">;
+    readonly openOrderSize: ToField<"u64">;
+    readonly nextOrderId: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): MarketInfoReified;
+    static get r(): reified.StructClassReified<MarketInfo, MarketInfoFields>;
+    static phantom(): PhantomReified<ToTypeStr<MarketInfo>>;
+    static get p(): reified.PhantomReified<"0x0::trading::MarketInfo">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        is_active: boolean;
+        size_decimal: string;
+        user_position_side: boolean;
+        position_size: string;
+        next_position_id: string;
+        open_order_side: boolean;
+        open_order_size: string;
+        next_order_id: string;
+        u64_padding: string[];
+    }, {
+        is_active: boolean;
+        size_decimal: string | number | bigint;
+        user_position_side: boolean;
+        position_size: string | number | bigint;
+        next_position_id: string | number | bigint;
+        open_order_side: boolean;
+        open_order_size: string | number | bigint;
+        next_order_id: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): MarketInfo;
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarketInfo;
+    static fromBcs(data: Uint8Array): MarketInfo;
+    toJSONField(): {
+        isActive: boolean;
+        sizeDecimal: string;
+        userPositionSide: boolean;
+        positionSize: string;
+        nextPositionId: string;
+        openOrderSide: boolean;
+        openOrderSize: string;
+        nextOrderId: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        isActive: boolean;
+        sizeDecimal: string;
+        userPositionSide: boolean;
+        positionSize: string;
+        nextPositionId: string;
+        openOrderSide: boolean;
+        openOrderSize: string;
+        nextOrderId: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): MarketInfo;
+    static fromJSON(json: Record<string, any>): MarketInfo;
+    static fromSuiParsedData(content: SuiParsedData): MarketInfo;
+    static fetch(client: SuiClient, id: string): Promise<MarketInfo>;
+}
+export declare function isMarketRegistry(type: string): boolean;
+export interface MarketRegistryFields {
+    id: ToField<UID>;
+    referralRegistry: ToField<UID>;
+    numMarket: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type MarketRegistryReified = Reified<MarketRegistry, MarketRegistryFields>;
+export declare class MarketRegistry implements StructClass {
+    static readonly $typeName = "0x0::trading::MarketRegistry";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::MarketRegistry";
+    readonly $fullTypeName: "0x0::trading::MarketRegistry";
+    readonly $typeArgs: [];
+    readonly id: ToField<UID>;
+    readonly referralRegistry: ToField<UID>;
+    readonly numMarket: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): MarketRegistryReified;
+    static get r(): reified.StructClassReified<MarketRegistry, MarketRegistryFields>;
+    static phantom(): PhantomReified<ToTypeStr<MarketRegistry>>;
+    static get p(): reified.PhantomReified<"0x0::trading::MarketRegistry">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        referral_registry: {
+            id: {
+                bytes: string;
+            };
+        };
+        num_market: string;
+        u64_padding: string[];
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        referral_registry: {
+            id: {
+                bytes: string;
+            };
+        };
+        num_market: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): MarketRegistry;
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarketRegistry;
+    static fromBcs(data: Uint8Array): MarketRegistry;
+    toJSONField(): {
+        id: string;
+        referralRegistry: string;
+        numMarket: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        id: string;
+        referralRegistry: string;
+        numMarket: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): MarketRegistry;
+    static fromJSON(json: Record<string, any>): MarketRegistry;
+    static fromSuiParsedData(content: SuiParsedData): MarketRegistry;
+    static fetch(client: SuiClient, id: string): Promise<MarketRegistry>;
+}
+export declare function isMarkets(type: string): boolean;
+export interface MarketsFields {
+    id: ToField<UID>;
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    quoteTokenType: ToField<TypeName>;
+    isActive: ToField<"bool">;
+    symbols: ToField<Vector<TypeName>>;
+    symbolMarkets: ToField<ObjectTable<ToPhantom<TypeName>, ToPhantom<SymbolMarket>>>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type MarketsReified = Reified<Markets, MarketsFields>;
+export declare class Markets implements StructClass {
+    static readonly $typeName = "0x0::trading::Markets";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::Markets";
+    readonly $fullTypeName: "0x0::trading::Markets";
+    readonly $typeArgs: [];
+    readonly id: ToField<UID>;
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly quoteTokenType: ToField<TypeName>;
+    readonly isActive: ToField<"bool">;
+    readonly symbols: ToField<Vector<TypeName>>;
+    readonly symbolMarkets: ToField<ObjectTable<ToPhantom<TypeName>, ToPhantom<SymbolMarket>>>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): MarketsReified;
+    static get r(): reified.StructClassReified<Markets, MarketsFields>;
+    static phantom(): PhantomReified<ToTypeStr<Markets>>;
+    static get p(): reified.PhantomReified<"0x0::trading::Markets">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        index: string;
+        lp_token_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        quote_token_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        is_active: boolean;
+        symbols: {
+            name: {
+                bytes: number[];
+            };
+        }[];
+        symbol_markets: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+        u64_padding: string[];
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        index: string | number | bigint;
+        lp_token_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        quote_token_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        is_active: boolean;
+        symbols: Iterable<{
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        }> & {
+            length: number;
+        };
+        symbol_markets: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): Markets;
+    static fromFieldsWithTypes(item: FieldsWithTypes): Markets;
+    static fromBcs(data: Uint8Array): Markets;
+    toJSONField(): {
+        id: string;
+        index: string;
+        lpTokenType: {
+            name: string;
+        };
+        quoteTokenType: {
+            name: string;
+        };
+        isActive: boolean;
+        symbols: {
+            name: string;
+        }[];
+        symbolMarkets: {
+            id: string;
+            size: string;
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        id: string;
+        index: string;
+        lpTokenType: {
+            name: string;
+        };
+        quoteTokenType: {
+            name: string;
+        };
+        isActive: boolean;
+        symbols: {
+            name: string;
+        }[];
+        symbolMarkets: {
+            id: string;
+            size: string;
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): Markets;
+    static fromJSON(json: Record<string, any>): Markets;
+    static fromSuiParsedData(content: SuiParsedData): Markets;
+    static fetch(client: SuiClient, id: string): Promise<Markets>;
+}
+export declare function isMatchTradingOrderEvent(type: string): boolean;
+export interface MatchTradingOrderEventFields {
+    sender: ToField<"address">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    matchedOrderIds: ToField<Vector<Vector<"u64">>>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type MatchTradingOrderEventReified = Reified<MatchTradingOrderEvent, MatchTradingOrderEventFields>;
+export declare class MatchTradingOrderEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::MatchTradingOrderEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::MatchTradingOrderEvent";
+    readonly $fullTypeName: "0x0::trading::MatchTradingOrderEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly matchedOrderIds: ToField<Vector<Vector<"u64">>>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): MatchTradingOrderEventReified;
+    static get r(): reified.StructClassReified<MatchTradingOrderEvent, MatchTradingOrderEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<MatchTradingOrderEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::MatchTradingOrderEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        collateral_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        matched_order_ids: string[][];
+        u64_padding: string[];
+    }, {
+        sender: string;
+        collateral_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        matched_order_ids: Iterable<Iterable<string | number | bigint> & {
+            length: number;
+        }> & {
+            length: number;
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): MatchTradingOrderEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): MatchTradingOrderEvent;
+    static fromBcs(data: Uint8Array): MatchTradingOrderEvent;
+    toJSONField(): {
+        sender: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        matchedOrderIds: string[][];
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        collateralToken: {
+            name: string;
+        };
+        baseToken: {
+            name: string;
+        };
+        matchedOrderIds: string[][];
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): MatchTradingOrderEvent;
+    static fromJSON(json: Record<string, any>): MatchTradingOrderEvent;
+    static fromSuiParsedData(content: SuiParsedData): MatchTradingOrderEvent;
+    static fetch(client: SuiClient, id: string): Promise<MatchTradingOrderEvent>;
+}
+export declare function isNewMarketsEvent(type: string): boolean;
+export interface NewMarketsEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    quoteTokenType: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type NewMarketsEventReified = Reified<NewMarketsEvent, NewMarketsEventFields>;
+export declare class NewMarketsEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::NewMarketsEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::NewMarketsEvent";
+    readonly $fullTypeName: "0x0::trading::NewMarketsEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly quoteTokenType: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): NewMarketsEventReified;
+    static get r(): reified.StructClassReified<NewMarketsEvent, NewMarketsEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<NewMarketsEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::NewMarketsEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        lp_token_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        quote_token_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        lp_token_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        quote_token_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): NewMarketsEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): NewMarketsEvent;
+    static fromBcs(data: Uint8Array): NewMarketsEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        lpTokenType: {
+            name: string;
+        };
+        quoteTokenType: {
+            name: string;
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        lpTokenType: {
+            name: string;
+        };
+        quoteTokenType: {
+            name: string;
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): NewMarketsEvent;
+    static fromJSON(json: Record<string, any>): NewMarketsEvent;
+    static fromSuiParsedData(content: SuiParsedData): NewMarketsEvent;
+    static fetch(client: SuiClient, id: string): Promise<NewMarketsEvent>;
+}
+export declare function isReferralInfo(type: string): boolean;
+export interface ReferralInfoFields {
+    invitedFrom: ToField<"address">;
+    feeRebateBp: ToField<"u64">;
+    feeReductionBp: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type ReferralInfoReified = Reified<ReferralInfo, ReferralInfoFields>;
+export declare class ReferralInfo implements StructClass {
+    static readonly $typeName = "0x0::trading::ReferralInfo";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::ReferralInfo";
+    readonly $fullTypeName: "0x0::trading::ReferralInfo";
+    readonly $typeArgs: [];
+    readonly invitedFrom: ToField<"address">;
+    readonly feeRebateBp: ToField<"u64">;
+    readonly feeReductionBp: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): ReferralInfoReified;
+    static get r(): reified.StructClassReified<ReferralInfo, ReferralInfoFields>;
+    static phantom(): PhantomReified<ToTypeStr<ReferralInfo>>;
+    static get p(): reified.PhantomReified<"0x0::trading::ReferralInfo">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        invited_from: string;
+        fee_rebate_bp: string;
+        fee_reduction_bp: string;
+        u64_padding: string[];
+    }, {
+        invited_from: string;
+        fee_rebate_bp: string | number | bigint;
+        fee_reduction_bp: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): ReferralInfo;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ReferralInfo;
+    static fromBcs(data: Uint8Array): ReferralInfo;
+    toJSONField(): {
+        invitedFrom: string;
+        feeRebateBp: string;
+        feeReductionBp: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        invitedFrom: string;
+        feeRebateBp: string;
+        feeReductionBp: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): ReferralInfo;
+    static fromJSON(json: Record<string, any>): ReferralInfo;
+    static fromSuiParsedData(content: SuiParsedData): ReferralInfo;
+    static fetch(client: SuiClient, id: string): Promise<ReferralInfo>;
+}
+export declare function isReferrals(type: string): boolean;
+export interface ReferralsFields {
+    id: ToField<UID>;
+    referrals: ToField<Table<"address", ToPhantom<ReferralInfo>>>;
+    rebates: ToField<Table<ToPhantom<TypeName>, ToPhantom<Table<"address", "u64">>>>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type ReferralsReified = Reified<Referrals, ReferralsFields>;
+export declare class Referrals implements StructClass {
+    static readonly $typeName = "0x0::trading::Referrals";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::Referrals";
+    readonly $fullTypeName: "0x0::trading::Referrals";
+    readonly $typeArgs: [];
+    readonly id: ToField<UID>;
+    readonly referrals: ToField<Table<"address", ToPhantom<ReferralInfo>>>;
+    readonly rebates: ToField<Table<ToPhantom<TypeName>, ToPhantom<Table<"address", "u64">>>>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): ReferralsReified;
+    static get r(): reified.StructClassReified<Referrals, ReferralsFields>;
+    static phantom(): PhantomReified<ToTypeStr<Referrals>>;
+    static get p(): reified.PhantomReified<"0x0::trading::Referrals">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        referrals: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+        rebates: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+        u64_padding: string[];
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        referrals: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+        rebates: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): Referrals;
+    static fromFieldsWithTypes(item: FieldsWithTypes): Referrals;
+    static fromBcs(data: Uint8Array): Referrals;
+    toJSONField(): {
+        id: string;
+        referrals: {
+            id: string;
+            size: string;
+        };
+        rebates: {
+            id: string;
+            size: string;
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        id: string;
+        referrals: {
+            id: string;
+            size: string;
+        };
+        rebates: {
+            id: string;
+            size: string;
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): Referrals;
+    static fromJSON(json: Record<string, any>): Referrals;
+    static fromSuiParsedData(content: SuiParsedData): Referrals;
+    static fetch(client: SuiClient, id: string): Promise<Referrals>;
+}
+export declare function isResumeMarketEvent(type: string): boolean;
+export interface ResumeMarketEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type ResumeMarketEventReified = Reified<ResumeMarketEvent, ResumeMarketEventFields>;
+export declare class ResumeMarketEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::ResumeMarketEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::ResumeMarketEvent";
+    readonly $fullTypeName: "0x0::trading::ResumeMarketEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): ResumeMarketEventReified;
+    static get r(): reified.StructClassReified<ResumeMarketEvent, ResumeMarketEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<ResumeMarketEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::ResumeMarketEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): ResumeMarketEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ResumeMarketEvent;
+    static fromBcs(data: Uint8Array): ResumeMarketEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): ResumeMarketEvent;
+    static fromJSON(json: Record<string, any>): ResumeMarketEvent;
+    static fromSuiParsedData(content: SuiParsedData): ResumeMarketEvent;
+    static fetch(client: SuiClient, id: string): Promise<ResumeMarketEvent>;
+}
+export declare function isResumeTradingSymbolEvent(type: string): boolean;
+export interface ResumeTradingSymbolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    resumedBaseToken: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type ResumeTradingSymbolEventReified = Reified<ResumeTradingSymbolEvent, ResumeTradingSymbolEventFields>;
+export declare class ResumeTradingSymbolEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::ResumeTradingSymbolEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::ResumeTradingSymbolEvent";
+    readonly $fullTypeName: "0x0::trading::ResumeTradingSymbolEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly resumedBaseToken: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): ResumeTradingSymbolEventReified;
+    static get r(): reified.StructClassReified<ResumeTradingSymbolEvent, ResumeTradingSymbolEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<ResumeTradingSymbolEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::ResumeTradingSymbolEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        resumed_base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        resumed_base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): ResumeTradingSymbolEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ResumeTradingSymbolEvent;
+    static fromBcs(data: Uint8Array): ResumeTradingSymbolEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        resumedBaseToken: {
+            name: string;
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        resumedBaseToken: {
+            name: string;
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): ResumeTradingSymbolEvent;
+    static fromJSON(json: Record<string, any>): ResumeTradingSymbolEvent;
+    static fromSuiParsedData(content: SuiParsedData): ResumeTradingSymbolEvent;
+    static fetch(client: SuiClient, id: string): Promise<ResumeTradingSymbolEvent>;
+}
+export declare function isSuspendMarketEvent(type: string): boolean;
+export interface SuspendMarketEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type SuspendMarketEventReified = Reified<SuspendMarketEvent, SuspendMarketEventFields>;
+export declare class SuspendMarketEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::SuspendMarketEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::SuspendMarketEvent";
+    readonly $fullTypeName: "0x0::trading::SuspendMarketEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): SuspendMarketEventReified;
+    static get r(): reified.StructClassReified<SuspendMarketEvent, SuspendMarketEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<SuspendMarketEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::SuspendMarketEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): SuspendMarketEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): SuspendMarketEvent;
+    static fromBcs(data: Uint8Array): SuspendMarketEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): SuspendMarketEvent;
+    static fromJSON(json: Record<string, any>): SuspendMarketEvent;
+    static fromSuiParsedData(content: SuiParsedData): SuspendMarketEvent;
+    static fetch(client: SuiClient, id: string): Promise<SuspendMarketEvent>;
+}
+export declare function isSuspendTradingSymbolEvent(type: string): boolean;
+export interface SuspendTradingSymbolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    suspendedBaseToken: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type SuspendTradingSymbolEventReified = Reified<SuspendTradingSymbolEvent, SuspendTradingSymbolEventFields>;
+export declare class SuspendTradingSymbolEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::SuspendTradingSymbolEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::SuspendTradingSymbolEvent";
+    readonly $fullTypeName: "0x0::trading::SuspendTradingSymbolEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly suspendedBaseToken: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): SuspendTradingSymbolEventReified;
+    static get r(): reified.StructClassReified<SuspendTradingSymbolEvent, SuspendTradingSymbolEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<SuspendTradingSymbolEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::SuspendTradingSymbolEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        suspended_base_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        suspended_base_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): SuspendTradingSymbolEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): SuspendTradingSymbolEvent;
+    static fromBcs(data: Uint8Array): SuspendTradingSymbolEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        suspendedBaseToken: {
+            name: string;
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        suspendedBaseToken: {
+            name: string;
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): SuspendTradingSymbolEvent;
+    static fromJSON(json: Record<string, any>): SuspendTradingSymbolEvent;
+    static fromSuiParsedData(content: SuiParsedData): SuspendTradingSymbolEvent;
+    static fetch(client: SuiClient, id: string): Promise<SuspendTradingSymbolEvent>;
+}
+export declare function isSymbolMarket(type: string): boolean;
+export interface SymbolMarketFields {
+    id: ToField<UID>;
+    userPositions: ToField<UID>;
+    userOrders: ToField<UID>;
+    marketInfo: ToField<MarketInfo>;
+    marketConfig: ToField<MarketConfig>;
+}
+export type SymbolMarketReified = Reified<SymbolMarket, SymbolMarketFields>;
+export declare class SymbolMarket implements StructClass {
+    static readonly $typeName = "0x0::trading::SymbolMarket";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::SymbolMarket";
+    readonly $fullTypeName: "0x0::trading::SymbolMarket";
+    readonly $typeArgs: [];
+    readonly id: ToField<UID>;
+    readonly userPositions: ToField<UID>;
+    readonly userOrders: ToField<UID>;
+    readonly marketInfo: ToField<MarketInfo>;
+    readonly marketConfig: ToField<MarketConfig>;
+    private constructor();
+    static reified(): SymbolMarketReified;
+    static get r(): reified.StructClassReified<SymbolMarket, SymbolMarketFields>;
+    static phantom(): PhantomReified<ToTypeStr<SymbolMarket>>;
+    static get p(): reified.PhantomReified<"0x0::trading::SymbolMarket">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        user_positions: {
+            id: {
+                bytes: string;
+            };
+        };
+        user_orders: {
+            id: {
+                bytes: string;
+            };
+        };
+        market_info: {
+            is_active: boolean;
+            size_decimal: string;
+            user_position_side: boolean;
+            position_size: string;
+            next_position_id: string;
+            open_order_side: boolean;
+            open_order_size: string;
+            next_order_id: string;
+            u64_padding: string[];
+        };
+        market_config: {
+            oracle_id: string;
+            max_leverage_pct: string;
+            min_size: string;
+            lot_size: string;
+            trading_fee_rate: string;
+            trading_fee_decimal: string;
+            u64_padding: string[];
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        user_positions: {
+            id: {
+                bytes: string;
+            };
+        };
+        user_orders: {
+            id: {
+                bytes: string;
+            };
+        };
+        market_info: {
+            is_active: boolean;
+            size_decimal: string | number | bigint;
+            user_position_side: boolean;
+            position_size: string | number | bigint;
+            next_position_id: string | number | bigint;
+            open_order_side: boolean;
+            open_order_size: string | number | bigint;
+            next_order_id: string | number | bigint;
+            u64_padding: Iterable<string | number | bigint> & {
+                length: number;
+            };
+        };
+        market_config: {
+            oracle_id: string;
+            max_leverage_pct: string | number | bigint;
+            min_size: string | number | bigint;
+            lot_size: string | number | bigint;
+            trading_fee_rate: string | number | bigint;
+            trading_fee_decimal: string | number | bigint;
+            u64_padding: Iterable<string | number | bigint> & {
+                length: number;
+            };
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): SymbolMarket;
+    static fromFieldsWithTypes(item: FieldsWithTypes): SymbolMarket;
+    static fromBcs(data: Uint8Array): SymbolMarket;
+    toJSONField(): {
+        id: string;
+        userPositions: string;
+        userOrders: string;
+        marketInfo: {
+            isActive: boolean;
+            sizeDecimal: string;
+            userPositionSide: boolean;
+            positionSize: string;
+            nextPositionId: string;
+            openOrderSide: boolean;
+            openOrderSize: string;
+            nextOrderId: string;
+            u64Padding: string[];
+        };
+        marketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+    };
+    toJSON(): {
+        id: string;
+        userPositions: string;
+        userOrders: string;
+        marketInfo: {
+            isActive: boolean;
+            sizeDecimal: string;
+            userPositionSide: boolean;
+            positionSize: string;
+            nextPositionId: string;
+            openOrderSide: boolean;
+            openOrderSize: string;
+            nextOrderId: string;
+            u64Padding: string[];
+        };
+        marketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): SymbolMarket;
+    static fromJSON(json: Record<string, any>): SymbolMarket;
+    static fromSuiParsedData(content: SuiParsedData): SymbolMarket;
+    static fetch(client: SuiClient, id: string): Promise<SymbolMarket>;
+}
+export declare function isUpdateMarketConfigEvent(type: string): boolean;
+export interface UpdateMarketConfigEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    baseTokenType: ToField<TypeName>;
+    previousMarketConfig: ToField<MarketConfig>;
+    newMarketConfig: ToField<MarketConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type UpdateMarketConfigEventReified = Reified<UpdateMarketConfigEvent, UpdateMarketConfigEventFields>;
+export declare class UpdateMarketConfigEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::UpdateMarketConfigEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::UpdateMarketConfigEvent";
+    readonly $fullTypeName: "0x0::trading::UpdateMarketConfigEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly baseTokenType: ToField<TypeName>;
+    readonly previousMarketConfig: ToField<MarketConfig>;
+    readonly newMarketConfig: ToField<MarketConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): UpdateMarketConfigEventReified;
+    static get r(): reified.StructClassReified<UpdateMarketConfigEvent, UpdateMarketConfigEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<UpdateMarketConfigEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::UpdateMarketConfigEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        index: string;
+        base_token_type: {
+            name: {
+                bytes: number[];
+            };
+        };
+        previous_market_config: {
+            oracle_id: string;
+            max_leverage_pct: string;
+            min_size: string;
+            lot_size: string;
+            trading_fee_rate: string;
+            trading_fee_decimal: string;
+            u64_padding: string[];
+        };
+        new_market_config: {
+            oracle_id: string;
+            max_leverage_pct: string;
+            min_size: string;
+            lot_size: string;
+            trading_fee_rate: string;
+            trading_fee_decimal: string;
+            u64_padding: string[];
+        };
+        u64_padding: string[];
+    }, {
+        sender: string;
+        index: string | number | bigint;
+        base_token_type: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        previous_market_config: {
+            oracle_id: string;
+            max_leverage_pct: string | number | bigint;
+            min_size: string | number | bigint;
+            lot_size: string | number | bigint;
+            trading_fee_rate: string | number | bigint;
+            trading_fee_decimal: string | number | bigint;
+            u64_padding: Iterable<string | number | bigint> & {
+                length: number;
+            };
+        };
+        new_market_config: {
+            oracle_id: string;
+            max_leverage_pct: string | number | bigint;
+            min_size: string | number | bigint;
+            lot_size: string | number | bigint;
+            trading_fee_rate: string | number | bigint;
+            trading_fee_decimal: string | number | bigint;
+            u64_padding: Iterable<string | number | bigint> & {
+                length: number;
+            };
+        };
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): UpdateMarketConfigEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateMarketConfigEvent;
+    static fromBcs(data: Uint8Array): UpdateMarketConfigEvent;
+    toJSONField(): {
+        sender: string;
+        index: string;
+        baseTokenType: {
+            name: string;
+        };
+        previousMarketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        newMarketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        index: string;
+        baseTokenType: {
+            name: string;
+        };
+        previousMarketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        newMarketConfig: {
+            oracleId: string;
+            maxLeveragePct: string;
+            minSize: string;
+            lotSize: string;
+            tradingFeeRate: string;
+            tradingFeeDecimal: string;
+            u64Padding: string[];
+        };
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): UpdateMarketConfigEvent;
+    static fromJSON(json: Record<string, any>): UpdateMarketConfigEvent;
+    static fromSuiParsedData(content: SuiParsedData): UpdateMarketConfigEvent;
+    static fetch(client: SuiClient, id: string): Promise<UpdateMarketConfigEvent>;
+}
+export declare function isUserOrders(type: string): boolean;
+export interface UserOrdersFields {
+    id: ToField<UID>;
+}
+export type UserOrdersReified = Reified<UserOrders, UserOrdersFields>;
+export declare class UserOrders implements StructClass {
+    static readonly $typeName = "0x0::trading::UserOrders";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::UserOrders";
+    readonly $fullTypeName: "0x0::trading::UserOrders";
+    readonly $typeArgs: [];
+    readonly id: ToField<UID>;
+    private constructor();
+    static reified(): UserOrdersReified;
+    static get r(): reified.StructClassReified<UserOrders, UserOrdersFields>;
+    static phantom(): PhantomReified<ToTypeStr<UserOrders>>;
+    static get p(): reified.PhantomReified<"0x0::trading::UserOrders">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): UserOrders;
+    static fromFieldsWithTypes(item: FieldsWithTypes): UserOrders;
+    static fromBcs(data: Uint8Array): UserOrders;
+    toJSONField(): {
+        id: string;
+    };
+    toJSON(): {
+        id: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): UserOrders;
+    static fromJSON(json: Record<string, any>): UserOrders;
+    static fromSuiParsedData(content: SuiParsedData): UserOrders;
+    static fetch(client: SuiClient, id: string): Promise<UserOrders>;
+}
+export declare function isUserPositions(type: string): boolean;
+export interface UserPositionsFields {
+    id: ToField<UID>;
+}
+export type UserPositionsReified = Reified<UserPositions, UserPositionsFields>;
+export declare class UserPositions implements StructClass {
+    static readonly $typeName = "0x0::trading::UserPositions";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::UserPositions";
+    readonly $fullTypeName: "0x0::trading::UserPositions";
+    readonly $typeArgs: [];
+    readonly id: ToField<UID>;
+    private constructor();
+    static reified(): UserPositionsReified;
+    static get r(): reified.StructClassReified<UserPositions, UserPositionsFields>;
+    static phantom(): PhantomReified<ToTypeStr<UserPositions>>;
+    static get p(): reified.PhantomReified<"0x0::trading::UserPositions">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): UserPositions;
+    static fromFieldsWithTypes(item: FieldsWithTypes): UserPositions;
+    static fromBcs(data: Uint8Array): UserPositions;
+    toJSONField(): {
+        id: string;
+    };
+    toJSON(): {
+        id: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): UserPositions;
+    static fromJSON(json: Record<string, any>): UserPositions;
+    static fromSuiParsedData(content: SuiParsedData): UserPositions;
+    static fetch(client: SuiClient, id: string): Promise<UserPositions>;
+}
+export declare function isWithdrawReferralRebateEvent(type: string): boolean;
+export interface WithdrawReferralRebateEventFields {
+    sender: ToField<"address">;
+    rebateToken: ToField<TypeName>;
+    amount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+export type WithdrawReferralRebateEventReified = Reified<WithdrawReferralRebateEvent, WithdrawReferralRebateEventFields>;
+export declare class WithdrawReferralRebateEvent implements StructClass {
+    static readonly $typeName = "0x0::trading::WithdrawReferralRebateEvent";
+    static readonly $numTypeParams = 0;
+    readonly $typeName = "0x0::trading::WithdrawReferralRebateEvent";
+    readonly $fullTypeName: "0x0::trading::WithdrawReferralRebateEvent";
+    readonly $typeArgs: [];
+    readonly sender: ToField<"address">;
+    readonly rebateToken: ToField<TypeName>;
+    readonly amount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    private constructor();
+    static reified(): WithdrawReferralRebateEventReified;
+    static get r(): reified.StructClassReified<WithdrawReferralRebateEvent, WithdrawReferralRebateEventFields>;
+    static phantom(): PhantomReified<ToTypeStr<WithdrawReferralRebateEvent>>;
+    static get p(): reified.PhantomReified<"0x0::trading::WithdrawReferralRebateEvent">;
+    static get bcs(): import("@mysten/bcs").BcsType<{
+        sender: string;
+        rebate_token: {
+            name: {
+                bytes: number[];
+            };
+        };
+        amount: string;
+        u64_padding: string[];
+    }, {
+        sender: string;
+        rebate_token: {
+            name: {
+                bytes: Iterable<number> & {
+                    length: number;
+                };
+            };
+        };
+        amount: string | number | bigint;
+        u64_padding: Iterable<string | number | bigint> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): WithdrawReferralRebateEvent;
+    static fromFieldsWithTypes(item: FieldsWithTypes): WithdrawReferralRebateEvent;
+    static fromBcs(data: Uint8Array): WithdrawReferralRebateEvent;
+    toJSONField(): {
+        sender: string;
+        rebateToken: {
+            name: string;
+        };
+        amount: string;
+        u64Padding: string[];
+    };
+    toJSON(): {
+        sender: string;
+        rebateToken: {
+            name: string;
+        };
+        amount: string;
+        u64Padding: string[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): WithdrawReferralRebateEvent;
+    static fromJSON(json: Record<string, any>): WithdrawReferralRebateEvent;
+    static fromSuiParsedData(content: SuiParsedData): WithdrawReferralRebateEvent;
+    static fetch(client: SuiClient, id: string): Promise<WithdrawReferralRebateEvent>;
+}