@0xmonaco/types 0.0.0-develop-20260415185155 → 0.0.0-develop-20260420223958

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>;
 /**
@@ -130,6 +158,11 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
         EXPIRED: "EXPIRED";
     }>>;
     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>;
 /**

package/dist/validation/trading.js

@@ -18,12 +18,21 @@ export const OrderSideSchema = z.enum(["BUY", "SELL"], {
 export const TradingModeSchema = z.enum(["SPOT", "MARGIN"], {
     message: 'Trading mode must be "SPOT" or "MARGIN"',
 });
+/**
+ * Position side validation
+ */
+export const PositionSideSchema = z.enum(["LONG", "SHORT", "NONE"], {
+    message: 'Position side must be "LONG", "SHORT", or "NONE"',
+});
 /**
  * Time in force validation
  */
 export const TimeInForceSchema = z.enum(["GTC", "IOC", "FOK"], {
     message: 'Time in force must be "GTC", "IOC", or "FOK"',
 });
+export const ConditionalTimeInForceSchema = z.enum(["GTC", "IOC"], {
+    message: 'Conditional order time in force must be "GTC" or "IOC"',
+});
 /**
  * Positive decimal string validation (for quantities and prices)
  */
@@ -58,7 +67,8 @@ export const SlippageToleranceSchema = z
 /**
  * Place Limit Order validation schema
  */
-export const PlaceLimitOrderSchema = z.object({
+export const PlaceLimitOrderSchema = z
+    .object({
     tradingPairId: UUIDSchema,
     side: OrderSideSchema,
     quantity: PositiveDecimalStringSchema,
@@ -69,13 +79,30 @@ export const PlaceLimitOrderSchema = z.object({
         useMasterBalance: z.boolean().optional(),
         expirationDate: ISO8601DateSchema.optional(),
         timeInForce: TimeInForceSchema.optional(),
+        marginAccountId: UUIDSchema.optional(),
+        positionSide: PositionSideSchema.optional(),
+        leverage: PositiveDecimalStringSchema.optional(),
+        reduceOnly: z.boolean().optional(),
     })
         .optional(),
+})
+    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.marginAccountId !== undefined, {
+    message: "marginAccountId is required for MARGIN orders",
+    path: ["options", "marginAccountId"],
+})
+    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.positionSide !== undefined, {
+    message: "positionSide is required for MARGIN orders",
+    path: ["options", "positionSide"],
+})
+    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.leverage !== undefined, {
+    message: "leverage is required for MARGIN orders",
+    path: ["options", "leverage"],
 });
 /**
  * Place Market Order validation schema
  */
-export const PlaceMarketOrderSchema = z.object({
+export const PlaceMarketOrderSchema = z
+    .object({
     tradingPairId: UUIDSchema,
     side: OrderSideSchema,
     quantity: PositiveDecimalStringSchema,
@@ -83,8 +110,24 @@ export const PlaceMarketOrderSchema = z.object({
         .object({
         tradingMode: TradingModeSchema.optional(),
         slippageTolerance: SlippageToleranceSchema,
+        marginAccountId: UUIDSchema.optional(),
+        positionSide: PositionSideSchema.optional(),
+        leverage: PositiveDecimalStringSchema.optional(),
+        reduceOnly: z.boolean().optional(),
     })
         .optional(),
+})
+    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.marginAccountId !== undefined, {
+    message: "marginAccountId is required for MARGIN orders",
+    path: ["options", "marginAccountId"],
+})
+    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.positionSide !== undefined, {
+    message: "positionSide is required for MARGIN orders",
+    path: ["options", "positionSide"],
+})
+    .refine((data) => data.options?.tradingMode !== "MARGIN" || data.options.leverage !== undefined, {
+    message: "leverage is required for MARGIN orders",
+    path: ["options", "leverage"],
 });
 /**
  * Cancel Order validation schema
@@ -121,6 +164,8 @@ export const ReplaceOrderSchema = z.object({
 export const GetPaginatedOrdersSchema = z.object({
     status: z.enum(ORDER_STATUS_VALUES).optional(),
     trading_pair_id: UUIDSchema.optional(),
+    trading_mode: TradingModeSchema.optional(),
+    margin_account_id: UUIDSchema.optional(),
     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(),
 });
@@ -130,6 +175,66 @@ export const GetPaginatedOrdersSchema = z.object({
 export const OrderTypeSchema = z.enum(["LIMIT", "MARKET"], {
     message: 'Order type must be "LIMIT" or "MARKET"',
 });
+export const ConditionalOrderConditionTypeSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT"], {
+    message: 'conditionType must be "STOP_LOSS" or "TAKE_PROFIT"',
+});
+export const ConditionalOrderTriggerSourceSchema = z.enum(["MARK_PRICE"], {
+    message: 'triggerSource must be "MARK_PRICE"',
+});
+export const ConditionalOrderStateSchema = z.enum(["ACTIVE", "TRIGGERING", "TRIGGERED", "CANCELLED", "EXPIRED", "FAILED"], {
+    message: "Invalid conditional order state",
+});
+export const ClosePositionSideSchema = z.enum(["LONG", "SHORT"], {
+    message: 'Position side must be "LONG" or "SHORT"',
+});
+export const SlippageToleranceBpsSchema = z
+    .number()
+    .int()
+    .min(0, "Slippage tolerance must be at least 0 bps")
+    .max(10000, "Slippage tolerance cannot exceed 10000 bps");
+export const CreateConditionalOrderSchema = z
+    .object({
+    tradingPairId: UUIDSchema,
+    marginAccountId: UUIDSchema,
+    conditionType: ConditionalOrderConditionTypeSchema,
+    triggerPrice: PositiveDecimalStringSchema,
+    triggerSource: ConditionalOrderTriggerSourceSchema.optional(),
+    side: OrderSideSchema,
+    positionSide: ClosePositionSideSchema,
+    orderType: OrderTypeSchema,
+    limitPrice: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema.optional(),
+    reduceOnly: z.boolean().optional(),
+    timeInForce: ConditionalTimeInForceSchema.optional(),
+    slippageToleranceBps: SlippageToleranceBpsSchema.optional(),
+    expiresAt: ISO8601DateSchema.optional(),
+})
+    .refine((data) => data.orderType !== "LIMIT" || data.limitPrice !== undefined, {
+    message: "limitPrice is required for LIMIT conditional orders",
+    path: ["limitPrice"],
+})
+    .refine((data) => data.orderType !== "MARKET" || data.limitPrice === undefined, {
+    message: "limitPrice must not be provided for MARKET conditional orders",
+    path: ["limitPrice"],
+})
+    .refine((data) => data.orderType !== "MARKET" || data.timeInForce === undefined, {
+    message: "timeInForce is only allowed for LIMIT conditional orders",
+    path: ["timeInForce"],
+})
+    .refine((data) => data.orderType !== "LIMIT" || data.slippageToleranceBps === undefined, {
+    message: "slippageToleranceBps is only allowed for MARKET conditional orders",
+    path: ["slippageToleranceBps"],
+});
+export const CancelConditionalOrderSchema = z.object({
+    conditionalOrderId: UUIDSchema,
+});
+export const ListConditionalOrdersSchema = z.object({
+    margin_account_id: UUIDSchema.optional(),
+    trading_pair_id: UUIDSchema.optional(),
+    state: ConditionalOrderStateSchema.optional(),
+    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(),
+});
 /**
  * Single batch create order item validation schema
  *
@@ -144,11 +249,15 @@ export const BatchCreateOrderItemSchema = z
     side: OrderSideSchema,
     price: PositiveDecimalStringSchema.optional(),
     quantity: PositiveDecimalStringSchema,
-    tradingMode: z.enum(["SPOT"]).optional(),
+    tradingMode: TradingModeSchema.optional(),
     slippageTolerance: SlippageToleranceSchema,
     useMasterBalance: z.boolean().optional(),
     expirationDate: ISO8601DateSchema.optional(),
     timeInForce: TimeInForceSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
+    positionSide: PositionSideSchema.optional(),
+    leverage: PositiveDecimalStringSchema.optional(),
+    reduceOnly: z.boolean().optional(),
 })
     .refine((data) => data.orderType !== "LIMIT" || data.price !== undefined, {
     message: "Price is required for LIMIT orders",
@@ -157,6 +266,18 @@ export const BatchCreateOrderItemSchema = z
     .refine((data) => data.orderType !== "MARKET" || data.price === undefined, {
     message: "Price must not be provided for MARKET orders",
     path: ["price"],
+})
+    .refine((data) => data.tradingMode !== "MARGIN" || data.marginAccountId !== undefined, {
+    message: "marginAccountId is required for MARGIN orders",
+    path: ["marginAccountId"],
+})
+    .refine((data) => data.tradingMode !== "MARGIN" || data.positionSide !== undefined, {
+    message: "positionSide is required for MARGIN orders",
+    path: ["positionSide"],
+})
+    .refine((data) => data.tradingMode !== "MARGIN" || data.leverage !== undefined, {
+    message: "leverage is required for MARGIN orders",
+    path: ["leverage"],
 });
 /**
  * Batch Create Orders validation schema