@0xmonaco/types 0.6.2 → 0.7.0

package/dist/trading/responses.d.ts

@@ -3,7 +3,7 @@
  *
  * Response types for trading operations.
  */
-import type { Order, OrderSide, OrderStatus, OrderType, TimeInForce, TradingMode } from "./orders";
+import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, Order, OrderSide, OrderStatus, OrderType, PositionSide, TimeInForce, TradingMode } from "./orders";
 /**
  * Match result information for order execution.
  * Contains detailed information about trades, fills, and execution quality.
@@ -97,7 +97,11 @@ export interface GetPaginatedOrdersParams {
     /** Filter by order status */
     status?: OrderStatus;
     /** Filter by trading pair UUID */
-    trading_pair?: string;
+    trading_pair_id?: string;
+    /** Filter by trading mode */
+    trading_mode?: TradingMode;
+    /** Filter by margin account UUID */
+    margin_account_id?: string;
     /** Page number for pagination (default: 1) */
     page?: number;
     /** Number of orders per page (default: 10, max: 100) */
@@ -147,8 +151,6 @@ export interface BatchCancelError {
 export interface BatchCancelResult {
     /** Order identifier */
     order_id: string;
-    /** Whether the cancellation was successful */
-    success: boolean;
     /** Timestamp when the order was canceled (ISO 8601 format) */
     cancelled_at?: string;
     /** Error details if the cancellation failed */
@@ -158,8 +160,6 @@ export interface BatchCancelResult {
  * Response from batch cancelling orders
  */
 export interface BatchCancelOrdersResponse {
-    /** Overall operation success */
-    success: boolean;
     /** Total number of orders requested to cancel */
     total_requested: number;
     /** Total number of orders successfully canceled */
@@ -184,8 +184,6 @@ export interface BatchError {
 export interface BatchCreateResult {
     /** Order identifier (empty string if creation failed before ID assignment) */
     order_id: string;
-    /** Whether the order was successfully created */
-    success: boolean;
     /** Match result information if the order was processed */
     match_result?: MatchResult;
     /** Error details if the creation failed */
@@ -195,8 +193,6 @@ export interface BatchCreateResult {
  * Response from batch creating orders
  */
 export interface BatchCreateOrdersResponse {
-    /** Overall operation success */
-    success: boolean;
     /** Total number of orders requested to create */
     total_requested: number;
     /** Total number of orders successfully created */
@@ -212,8 +208,6 @@ export interface BatchCreateOrdersResponse {
 export interface BatchReplaceResult {
     /** Original order identifier */
     original_order_id: string;
-    /** Whether the order was successfully replaced */
-    success: boolean;
     /** New order identifier (if successful) */
     new_order_id?: string;
     /** Fields that were updated (if successful) */
@@ -227,8 +221,6 @@ export interface BatchReplaceResult {
  * Response from batch replacing orders
  */
 export interface BatchReplaceOrdersResponse {
-    /** Overall operation success */
-    success: boolean;
     /** Total number of orders requested to replace */
     total_requested: number;
     /** Total number of orders successfully replaced */
@@ -253,7 +245,7 @@ export interface BatchCreateOrderParams {
     /** Order quantity */
     quantity: string;
     /** Trading mode (defaults to "SPOT") */
-    tradingMode?: Extract<TradingMode, "SPOT">;
+    tradingMode?: TradingMode;
     /** Maximum slippage for market orders as decimal (e.g., 0.01 for 1%) */
     slippageTolerance?: number;
     /** For sub-accounts: use master's balance */
@@ -262,6 +254,14 @@ export interface BatchCreateOrderParams {
     expirationDate?: string;
     /** Time in force: "GTC", "IOC", or "FOK" */
     timeInForce?: Extract<TimeInForce, "GTC" | "IOC" | "FOK">;
+    /** Margin account UUID for margin/perp orders */
+    marginAccountId?: string;
+    /** Position side for margin/perp orders */
+    positionSide?: PositionSide;
+    /** Leverage for margin/perp orders */
+    leverage?: string;
+    /** Whether the order can only reduce existing exposure */
+    reduceOnly?: boolean;
 }
 /**
  * Parameters for a single order in a batch replace request
@@ -276,3 +276,72 @@ export interface BatchReplaceOrderParams {
     /** For sub-accounts: use master's balance (optional) */
     useMasterBalance?: boolean;
 }
+/**
+ * Parameters for creating a standalone conditional TP/SL order.
+ */
+export interface CreateConditionalOrderParams {
+    tradingPairId: string;
+    marginAccountId: string;
+    conditionType: ConditionalOrderConditionType;
+    triggerPrice: string;
+    triggerSource?: ConditionalOrderTriggerSource;
+    side: OrderSide;
+    positionSide: Exclude<PositionSide, "NONE">;
+    orderType: OrderType;
+    limitPrice?: string;
+    quantity?: string;
+    reduceOnly?: boolean;
+    timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
+    slippageToleranceBps?: number;
+    expiresAt?: string;
+}
+export interface CreateConditionalOrderResponse {
+    conditional_order_id: string;
+    status: "SUCCESS" | "FAILED";
+    message: string;
+    state: ConditionalOrderState;
+}
+export interface CancelConditionalOrderResponse {
+    conditional_order_id: string;
+    status: "SUCCESS" | "FAILED";
+    message: string;
+}
+export interface ListConditionalOrdersParams {
+    margin_account_id?: string;
+    trading_pair_id?: string;
+    state?: ConditionalOrderState;
+    page?: number;
+    page_size?: number;
+}
+export interface ConditionalOrder {
+    conditional_order_id: string;
+    trading_pair_id: string;
+    margin_account_id: string;
+    position_id?: string;
+    linked_group_id?: string;
+    condition_type: ConditionalOrderConditionType;
+    trigger_source: ConditionalOrderTriggerSource;
+    trigger_price: string;
+    side: OrderSide;
+    position_side: PositionSide;
+    order_type: OrderType;
+    limit_price?: string;
+    quantity?: string;
+    slippage_tolerance_bps?: number;
+    reduce_only: boolean;
+    time_in_force?: TimeInForce;
+    state: ConditionalOrderState;
+    triggered_order_id?: string;
+    triggered_at?: string;
+    cancelled_at?: string;
+    expires_at?: string;
+    failure_reason?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface ListConditionalOrdersResponse {
+    orders: ConditionalOrder[];
+    total: number;
+    page: number;
+    page_size: number;
+}

package/dist/validation/index.d.ts

@@ -14,7 +14,9 @@
  * - Market schemas (trading pairs, candlesticks)
  */
 export * from "./common.js";
+export * from "./margin-accounts.js";
 export * from "./market.js";
+export * from "./positions.js";
 export * from "./profile.js";
 export * from "./trading.js";
 export * from "./vault.js";

package/dist/validation/index.js

@@ -15,7 +15,9 @@
  */
 // Export validation utilities
 export * from "./common.js";
+export * from "./margin-accounts.js";
 export * from "./market.js";
+export * from "./positions.js";
 // Export module-specific schemas
 export * from "./profile.js";
 export * from "./trading.js";

package/dist/validation/margin-accounts.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Margin Account API Validation Schemas
+ */
+import { z } from "zod";
+export declare const ListMarginAccountsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CreateMarginAccountSchema: z.ZodOptional<z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    collateralAsset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const GetMarginAccountSummarySchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const GetAvailableCollateralSchema: z.ZodOptional<z.ZodObject<{
+    asset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const TransferCollateralSchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+    request: z.ZodObject<{
+        asset: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const GetMarginAccountMovementsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    marginAccountId: z.ZodUUID;
+    movement_type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SimulateOrderRiskSchema: z.ZodObject<{
+    marginAccountId: z.ZodUUID;
+    request: z.ZodObject<{
+        tradingPairId: z.ZodUUID;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        positionSide: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+            NONE: "NONE";
+        }>;
+        orderType: z.ZodEnum<{
+            LIMIT: "LIMIT";
+            MARKET: "MARKET";
+        }>;
+        price: z.ZodOptional<z.ZodString>;
+        quantity: z.ZodString;
+        leverage: z.ZodString;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/validation/margin-accounts.js

@@ -0,0 +1,59 @@
+/**
+ * Margin Account API Validation Schemas
+ */
+import { z } from "zod";
+import { OrderSideSchema, OrderTypeSchema, PositionSideSchema, PositiveDecimalStringSchema, UUIDSchema } from "./trading";
+const PaginationSchema = z.object({
+    page: z.number().int().min(1, "Page must be at least 1").optional(),
+    page_size: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+});
+export const ListMarginAccountsSchema = PaginationSchema.extend({
+    state: z.string().trim().min(1, "State cannot be empty").optional(),
+});
+export const CreateMarginAccountSchema = z
+    .object({
+    label: z.string().trim().min(1, "Label cannot be empty").optional(),
+    collateralAsset: z.string().trim().min(1, "Collateral asset cannot be empty").optional(),
+})
+    .optional();
+export const GetMarginAccountSummarySchema = z.object({
+    marginAccountId: UUIDSchema,
+});
+export const GetAvailableCollateralSchema = z
+    .object({
+    asset: z.string().trim().min(1, "Asset cannot be empty").optional(),
+})
+    .optional();
+export const TransferCollateralSchema = z.object({
+    marginAccountId: UUIDSchema,
+    request: z.object({
+        asset: z.string().trim().min(1, "Asset cannot be empty"),
+        amount: PositiveDecimalStringSchema,
+    }),
+});
+export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
+    marginAccountId: UUIDSchema,
+    movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
+});
+export const SimulateOrderRiskSchema = z
+    .object({
+    marginAccountId: UUIDSchema,
+    request: z.object({
+        tradingPairId: UUIDSchema,
+        side: OrderSideSchema,
+        positionSide: PositionSideSchema,
+        orderType: OrderTypeSchema,
+        price: PositiveDecimalStringSchema.optional(),
+        quantity: PositiveDecimalStringSchema,
+        leverage: PositiveDecimalStringSchema,
+        reduceOnly: z.boolean().optional(),
+    }),
+})
+    .refine((data) => data.request.orderType !== "LIMIT" || data.request.price !== undefined, {
+    message: "price is required for LIMIT risk simulations",
+    path: ["request", "price"],
+})
+    .refine((data) => data.request.orderType !== "MARKET" || data.request.price === undefined, {
+    message: "price must not be provided for MARKET risk simulations",
+    path: ["request", "price"],
+});

package/dist/validation/positions.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Positions API Validation Schemas
+ */
+import { z } from "zod";
+export declare const ListPositionsSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    status: z.ZodOptional<z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+        LIQUIDATING: "LIQUIDATING";
+    }>>;
+}, z.core.$strip>;
+export declare const GetPositionSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const ClosePositionSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        closeType: z.ZodEnum<{
+            LIMIT: "LIMIT";
+            MARKET: "MARKET";
+            IOC: "IOC";
+        }>;
+        limitPrice: z.ZodOptional<z.ZodString>;
+        slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+        quantity: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const GetPositionRiskSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const AddPositionMarginSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        amount: z.ZodString;
+        asset: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ReducePositionMarginSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        amount: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AttachPositionTpSlSchema: z.ZodObject<{
+    positionId: z.ZodUUID;
+    request: z.ZodObject<{
+        takeProfit: z.ZodOptional<z.ZodObject<{
+            triggerPrice: z.ZodString;
+            orderType: z.ZodEnum<{
+                LIMIT: "LIMIT";
+                MARKET: "MARKET";
+            }>;
+            limitPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+            }>>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        stopLoss: z.ZodOptional<z.ZodObject<{
+            triggerPrice: z.ZodString;
+            orderType: z.ZodEnum<{
+                LIMIT: "LIMIT";
+                MARKET: "MARKET";
+            }>;
+            limitPrice: z.ZodOptional<z.ZodString>;
+            quantity: z.ZodOptional<z.ZodString>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+            }>>;
+            slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+            expiresAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ListPositionHistorySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+    position_id: z.ZodOptional<z.ZodUUID>;
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strip>;

package/dist/validation/positions.js

@@ -0,0 +1,93 @@
+/**
+ * Positions API Validation Schemas
+ */
+import { z } from "zod";
+import { ConditionalTimeInForceSchema, ISO8601DateSchema, OrderTypeSchema, PositiveDecimalStringSchema, SlippageToleranceBpsSchema, UUIDSchema, } from "./trading";
+const PaginationSchema = z.object({
+    page: z.number().int().min(1, "Page must be at least 1").optional(),
+    page_size: z.number().int().min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+});
+const PositionStatusSchema = z.enum(["OPEN", "CLOSED", "LIQUIDATING"], {
+    message: 'Position status must be "OPEN", "CLOSED", or "LIQUIDATING"',
+});
+const ClosePositionTypeSchema = z.enum(["MARKET", "LIMIT", "IOC"], {
+    message: 'Close type must be "MARKET", "LIMIT", or "IOC"',
+});
+const PositionIdSchema = z.object({
+    positionId: UUIDSchema,
+});
+export const ListPositionsSchema = PaginationSchema.extend({
+    margin_account_id: UUIDSchema.optional(),
+    trading_pair_id: UUIDSchema.optional(),
+    status: PositionStatusSchema.optional(),
+});
+export const GetPositionSchema = PositionIdSchema;
+export const ClosePositionSchema = PositionIdSchema.extend({
+    request: z.object({
+        closeType: ClosePositionTypeSchema,
+        limitPrice: PositiveDecimalStringSchema.optional(),
+        slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+        quantity: PositiveDecimalStringSchema.optional(),
+    }),
+})
+    .refine((data) => data.request.closeType !== "LIMIT" || data.request.limitPrice !== undefined, {
+    message: "limitPrice is required for LIMIT close requests",
+    path: ["request", "limitPrice"],
+})
+    .refine((data) => data.request.closeType === "LIMIT" || data.request.limitPrice === undefined, {
+    message: "limitPrice is only allowed for LIMIT close requests",
+    path: ["request", "limitPrice"],
+});
+export const GetPositionRiskSchema = PositionIdSchema;
+export const AddPositionMarginSchema = PositionIdSchema.extend({
+    request: z.object({
+        amount: PositiveDecimalStringSchema,
+        asset: z.string().trim().min(1, "Asset cannot be empty"),
+    }),
+});
+export const ReducePositionMarginSchema = PositionIdSchema.extend({
+    request: z.object({
+        amount: PositiveDecimalStringSchema,
+    }),
+});
+const TpSlLegSchema = z
+    .object({
+    triggerPrice: PositiveDecimalStringSchema,
+    orderType: OrderTypeSchema,
+    limitPrice: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema.optional(),
+    timeInForce: ConditionalTimeInForceSchema.optional(),
+    slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+    expiresAt: ISO8601DateSchema.optional(),
+})
+    .refine((data) => data.orderType !== "LIMIT" || data.limitPrice !== undefined, {
+    message: "limitPrice is required for LIMIT TP/SL legs",
+    path: ["limitPrice"],
+})
+    .refine((data) => data.orderType !== "MARKET" || data.limitPrice === undefined, {
+    message: "limitPrice must not be provided for MARKET TP/SL legs",
+    path: ["limitPrice"],
+})
+    .refine((data) => data.orderType !== "MARKET" || data.timeInForce === undefined, {
+    message: "timeInForce is only allowed for LIMIT TP/SL legs",
+    path: ["timeInForce"],
+})
+    .refine((data) => data.orderType !== "LIMIT" || data.slippageToleranceBps === undefined, {
+    message: "slippageToleranceBps is only allowed for MARKET TP/SL legs",
+    path: ["slippageToleranceBps"],
+});
+export const AttachPositionTpSlSchema = PositionIdSchema.extend({
+    request: z
+        .object({
+        takeProfit: TpSlLegSchema.optional(),
+        stopLoss: TpSlLegSchema.optional(),
+    })
+        .refine((data) => data.takeProfit !== undefined || data.stopLoss !== undefined, {
+        message: "At least one of takeProfit or stopLoss is required",
+    }),
+});
+export const ListPositionHistorySchema = PaginationSchema.extend({
+    position_id: UUIDSchema.optional(),
+    margin_account_id: UUIDSchema.optional(),
+    trading_pair_id: UUIDSchema.optional(),
+});

package/dist/validation/trading.d.ts

@@ -19,6 +19,14 @@ export declare const TradingModeSchema: z.ZodEnum<{
     SPOT: "SPOT";
     MARGIN: "MARGIN";
 }>;
+/**
+ * Position side validation
+ */
+export declare const PositionSideSchema: z.ZodEnum<{
+    LONG: "LONG";
+    SHORT: "SHORT";
+    NONE: "NONE";
+}>;
 /**
  * Time in force validation
  */
@@ -27,6 +35,10 @@ export declare const TimeInForceSchema: z.ZodEnum<{
     IOC: "IOC";
     FOK: "FOK";
 }>;
+export declare const ConditionalTimeInForceSchema: z.ZodEnum<{
+    GTC: "GTC";
+    IOC: "IOC";
+}>;
 /**
  * Positive decimal string validation (for quantities and prices)
  */
@@ -66,6 +78,14 @@ export declare const PlaceLimitOrderSchema: z.ZodObject<{
             IOC: "IOC";
             FOK: "FOK";
         }>>;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
+        positionSide: z.ZodOptional<z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+            NONE: "NONE";
+        }>>;
+        leverage: z.ZodOptional<z.ZodString>;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
@@ -84,6 +104,14 @@ export declare const PlaceMarketOrderSchema: z.ZodObject<{
             MARGIN: "MARGIN";
         }>>;
         slippageTolerance: z.ZodOptional<z.ZodNumber>;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
+        positionSide: z.ZodOptional<z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+            NONE: "NONE";
+        }>>;
+        leverage: z.ZodOptional<z.ZodString>;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
@@ -114,7 +142,7 @@ export declare const ReplaceOrderSchema: z.ZodObject<{
  * Validates parameters for fetching paginated orders.
  * Matches the getPaginatedOrders method signature which accepts:
  * - status: OrderStatus (optional filter)
- * - trading_pair: trading pair UUID (optional filter)
+ * - trading_pair_id: trading pair UUID (optional filter)
  * - page: number (default: 1)
  * - page_size: number (default: 10, max: 100)
  */
@@ -129,7 +157,12 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
         REJECTED: "REJECTED";
         EXPIRED: "EXPIRED";
     }>>;
-    trading_pair: z.ZodOptional<z.ZodUUID>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    trading_mode: z.ZodOptional<z.ZodEnum<{
+        SPOT: "SPOT";
+        MARGIN: "MARGIN";
+    }>>;
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
     page: z.ZodOptional<z.ZodNumber>;
     page_size: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -140,6 +173,76 @@ export declare const OrderTypeSchema: z.ZodEnum<{
     LIMIT: "LIMIT";
     MARKET: "MARKET";
 }>;
+export declare const ConditionalOrderConditionTypeSchema: z.ZodEnum<{
+    STOP_LOSS: "STOP_LOSS";
+    TAKE_PROFIT: "TAKE_PROFIT";
+}>;
+export declare const ConditionalOrderTriggerSourceSchema: z.ZodEnum<{
+    MARK_PRICE: "MARK_PRICE";
+}>;
+export declare const ConditionalOrderStateSchema: z.ZodEnum<{
+    CANCELLED: "CANCELLED";
+    EXPIRED: "EXPIRED";
+    ACTIVE: "ACTIVE";
+    TRIGGERING: "TRIGGERING";
+    TRIGGERED: "TRIGGERED";
+    FAILED: "FAILED";
+}>;
+export declare const ClosePositionSideSchema: z.ZodEnum<{
+    LONG: "LONG";
+    SHORT: "SHORT";
+}>;
+export declare const SlippageToleranceBpsSchema: z.ZodNumber;
+export declare const CreateConditionalOrderSchema: z.ZodObject<{
+    tradingPairId: z.ZodUUID;
+    marginAccountId: z.ZodUUID;
+    conditionType: z.ZodEnum<{
+        STOP_LOSS: "STOP_LOSS";
+        TAKE_PROFIT: "TAKE_PROFIT";
+    }>;
+    triggerPrice: z.ZodString;
+    triggerSource: z.ZodOptional<z.ZodEnum<{
+        MARK_PRICE: "MARK_PRICE";
+    }>>;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    positionSide: z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+    }>;
+    orderType: z.ZodEnum<{
+        LIMIT: "LIMIT";
+        MARKET: "MARKET";
+    }>;
+    limitPrice: z.ZodOptional<z.ZodString>;
+    quantity: z.ZodOptional<z.ZodString>;
+    reduceOnly: z.ZodOptional<z.ZodBoolean>;
+    timeInForce: z.ZodOptional<z.ZodEnum<{
+        GTC: "GTC";
+        IOC: "IOC";
+    }>>;
+    slippageToleranceBps: z.ZodOptional<z.ZodNumber>;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export declare const CancelConditionalOrderSchema: z.ZodObject<{
+    conditionalOrderId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const ListConditionalOrdersSchema: z.ZodObject<{
+    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    state: z.ZodOptional<z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        EXPIRED: "EXPIRED";
+        ACTIVE: "ACTIVE";
+        TRIGGERING: "TRIGGERING";
+        TRIGGERED: "TRIGGERED";
+        FAILED: "FAILED";
+    }>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 /**
  * Single batch create order item validation schema
  *
@@ -161,6 +264,7 @@ export declare const BatchCreateOrderItemSchema: z.ZodObject<{
     quantity: z.ZodString;
     tradingMode: z.ZodOptional<z.ZodEnum<{
         SPOT: "SPOT";
+        MARGIN: "MARGIN";
     }>>;
     slippageTolerance: z.ZodOptional<z.ZodNumber>;
     useMasterBalance: z.ZodOptional<z.ZodBoolean>;
@@ -170,6 +274,14 @@ export declare const BatchCreateOrderItemSchema: z.ZodObject<{
         IOC: "IOC";
         FOK: "FOK";
     }>>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    positionSide: z.ZodOptional<z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+        NONE: "NONE";
+    }>>;
+    leverage: z.ZodOptional<z.ZodString>;
+    reduceOnly: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 /**
  * Batch Create Orders validation schema
@@ -191,6 +303,7 @@ export declare const BatchCreateOrdersSchema: z.ZodObject<{
         quantity: z.ZodString;
         tradingMode: z.ZodOptional<z.ZodEnum<{
             SPOT: "SPOT";
+            MARGIN: "MARGIN";
         }>>;
         slippageTolerance: z.ZodOptional<z.ZodNumber>;
         useMasterBalance: z.ZodOptional<z.ZodBoolean>;
@@ -200,6 +313,14 @@ export declare const BatchCreateOrdersSchema: z.ZodObject<{
             IOC: "IOC";
             FOK: "FOK";
         }>>;
+        marginAccountId: z.ZodOptional<z.ZodUUID>;
+        positionSide: z.ZodOptional<z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+            NONE: "NONE";
+        }>>;
+        leverage: z.ZodOptional<z.ZodString>;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**