@0xmonaco/types 0.6.3 → 0.7.0

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>;
 /**

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
@@ -114,13 +157,15 @@ export const ReplaceOrderSchema = z.object({
  * 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)
  */
 export const GetPaginatedOrdersSchema = z.object({
     status: z.enum(ORDER_STATUS_VALUES).optional(),
-    trading_pair: UUIDSchema.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

package/dist/websocket/events/conditional-order-events.d.ts

@@ -0,0 +1,33 @@
+import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalOrderTriggerSource, OrderSide, OrderType, PositionSide, TimeInForce } from "../../trading";
+export type ConditionalOrderEventReason = "created" | "cancelled" | "triggered" | "failed" | "oco_cancelled";
+export interface ConditionalOrderEventData {
+    conditionalOrderId: string;
+    tradingPairId: string;
+    marginAccountId: string;
+    positionId?: string;
+    linkedGroupId?: string;
+    conditionType: ConditionalOrderConditionType;
+    triggerSource: ConditionalOrderTriggerSource;
+    triggerPrice: string;
+    side: OrderSide;
+    positionSide: PositionSide;
+    orderType: OrderType;
+    limitPrice?: string;
+    quantity?: string;
+    slippageToleranceBps?: number;
+    reduceOnly: boolean;
+    timeInForce?: Extract<TimeInForce, "GTC" | "IOC">;
+    state: ConditionalOrderState;
+    triggeredOrderId?: string;
+    triggeredAt?: string;
+    cancelledAt?: string;
+    expiresAt?: string;
+    failureReason?: string;
+    reason: ConditionalOrderEventReason;
+    updatedAt: string;
+}
+export interface ConditionalOrderEvent {
+    eventType: "conditional_order_update";
+    userId: string;
+    data: ConditionalOrderEventData;
+}

package/dist/websocket/events/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./balance-events";
+export * from "./conditional-order-events";
 export * from "./movement-events";
 export * from "./ohlcv-events";
 export * from "./orderbook-events";

package/dist/websocket/events/index.js

@@ -1,4 +1,5 @@
 export * from "./balance-events";
+export * from "./conditional-order-events";
 export * from "./movement-events";
 export * from "./ohlcv-events";
 export * from "./orderbook-events";

package/dist/websocket/events/orders-events.d.ts

@@ -38,7 +38,7 @@ export interface CommonOrderEventData {
     /** Application ID (UUID) - present in several events */
     applicationId?: string;
     /** Trading pair symbol (e.g., "BTC/USDC") */
-    tradingPair: string;
+    symbol: string;
     /** Trading mode (e.g., "SPOT", "MARGIN") */
     tradingMode: TradingMode;
     /** Order type - present in most events */
@@ -278,7 +278,7 @@ export interface BackendCommonOrderEventData {
     /** Trading pair ID (UUID) */
     trading_pair_id?: string;
     /** Trading pair symbol (e.g., "BTC/USDC") */
-    trading_pair: string;
+    symbol: string;
     /** Trading mode (e.g., "Spot", "Margin") */
     trading_mode: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "0.6.3",
+	"version": "0.7.0",
 	"type": "module",
 	"repository": {
 		"type": "git",