@0xmonaco/types 0.8.14 → 0.8.15

package/dist/trading/index.d.ts

@@ -120,9 +120,9 @@ export interface TradingAPI extends BaseAPI {
      * Gets paginated orders based on query parameters.
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (optional)
-     * @param params.trading_pair_id - Filter by trading pair UUID (optional)
+     * @param params.tradingPairId - Filter by trading pair UUID (optional)
      * @param params.page - Page number for pagination (optional)
-     * @param params.page_size - Number of orders per page (optional)
+     * @param params.pageSize - Number of orders per page (optional)
      * @returns Promise resolving to the paginated orders result
      */
     getPaginatedOrders(params?: GetPaginatedOrdersParams): Promise<GetPaginatedOrdersResponse>;

package/dist/trading/orders.d.ts

@@ -16,18 +16,18 @@
  * @example
  * To calculate remaining quantity:
  * ```typescript
- * const remaining = parseFloat(order.quantity) - parseFloat(order.filled_quantity);
+ * const remaining = parseFloat(order.quantity) - parseFloat(order.filledQuantity);
  * ```
  */
 export interface Order {
     /** Order identifier (UUID) */
     id: string;
     /** Trading pair ID (UUID format, e.g., "456e7890-e12b-12d3-a456-426614174000") */
-    trading_pair_id: string;
+    tradingPairId: string;
     /** Order side (BUY or SELL) */
     side: OrderSide;
     /** Order type - see OrderType for all supported types */
-    order_type: OrderType;
+    orderType: OrderType;
     /** Order status - see OrderStatus for lifecycle details */
     status: OrderStatus;
     /** Order price - null for market orders, required for limit orders */
@@ -35,41 +35,41 @@ export interface Order {
     /** Order quantity (base currency amount) */
     quantity: string;
     /** Filled quantity (base currency amount, "0" if unfilled) */
-    filled_quantity: string;
+    filledQuantity: string;
     /** Average fill price - only populated after order has fills */
-    average_fill_price?: string;
+    averageFillPrice?: string;
     /** Trading mode (SPOT or MARGIN) */
-    trading_mode: TradingMode;
+    tradingMode: TradingMode;
     /** Time in force - GTC, IOC, FOK, or GTD */
-    time_in_force?: TimeInForce;
+    timeInForce?: TimeInForce;
     /** Order creation timestamp (ISO 8601) */
-    created_at: string;
+    createdAt: string;
     /** Order last update timestamp (ISO 8601) */
-    updated_at?: string;
+    updatedAt?: string;
     /** Optional expiration date for GTD orders (ISO 8601, max 1 year) */
-    expiration_date?: string;
+    expirationDate?: string;
     /** Application taker fee in basis points (e.g., "100" = 1%) - populated after fills */
-    application_taker_fee?: string;
+    applicationTakerFee?: string;
     /** Monaco protocol taker fee in basis points - populated after fills */
-    monaco_taker_fee?: string;
+    monacoTakerFee?: string;
     /** Monaco protocol maker rebate in basis points - populated after fills */
-    monaco_maker_rebate?: string;
+    monacoMakerRebate?: string;
     /** Total taker fees paid in quote currency - populated after fills */
-    total_taker_fees?: string;
+    totalTakerFees?: string;
     /** Total payment for taker including fees in quote currency - populated after fills */
-    taker_total_payment?: string;
+    takerTotalPayment?: string;
     /** Total receipt for maker after rebates in quote currency - populated after fills */
-    maker_total_receipt?: string;
+    makerTotalReceipt?: string;
     /** Margin account ID for margin/perp orders */
-    margin_account_id?: string;
+    marginAccountId?: string;
     /** Position side for margin/perp orders */
-    position_side?: PositionSide;
+    positionSide?: PositionSide;
     /** Leverage used for margin/perp orders */
     leverage?: string;
     /** Whether the order can only reduce existing exposure */
-    reduce_only?: boolean;
+    reduceOnly?: boolean;
     /** Position ID linked to the order, when available */
-    position_id?: string;
+    positionId?: string;
 }
 /**
  * Role of the creator or order

package/dist/trading/responses.d.ts

@@ -15,25 +15,25 @@ import type { ConditionalOrderConditionType, ConditionalOrderState, ConditionalO
  */
 export interface MatchResult {
     /** Number of trades executed during matching */
-    trades_count: number;
+    tradesCount: number;
     /** Total quantity filled across all trades (in base currency) */
-    total_filled: string;
+    totalFilled: string;
     /** Remaining unfilled quantity after immediate matches (in base currency) */
-    remaining_quantity: string;
+    remainingQuantity: string;
     /** Average fill price across all trades (null if no fills occurred) */
-    average_fill_price: string | null;
+    averageFillPrice: string | null;
     /** Final order status after matching (e.g., FILLED, PARTIALLY_FILLED, etc.) */
     status: OrderStatus;
     /** Actual slippage experienced in basis points (positive = worse price, null if no fills) */
-    actual_slippage_bps: number | null;
+    actualSlippageBps: number | null;
     /** Maximum slippage allowed when order was submitted in basis points (null if not set) */
-    max_slippage_bps: number | null;
+    maxSlippageBps: number | null;
     /** Price range across executed trades (null if no fills) */
-    execution_price_range: {
+    executionPriceRange: {
         /** Best (most favorable) execution price achieved */
-        best_price: string;
+        bestPrice: string;
         /** Worst (least favorable) execution price achieved */
-        worst_price: string;
+        worstPrice: string;
     } | null;
 }
 /**
@@ -65,32 +65,32 @@ export interface ParentTpSlLegParams {
  */
 export interface CreateOrderResponse {
     /** Created order identifier (UUID) */
-    order_id: string;
+    orderId: string;
     /** Operation status (SUCCESS or FAILED) */
     status: "SUCCESS" | "FAILED";
     /** Operation message describing the result (e.g., "Order processed with 2 trades") */
     message: string;
     /** Match result information if order was processed by matching engine */
-    match_result?: MatchResult;
+    matchResult?: MatchResult;
     /** Resolved margin account ID for margin/perp orders */
-    margin_account_id?: string;
+    marginAccountId?: string;
     /** Resolved isolated risk bucket ID for risk-bucket-scoped margin orders */
-    risk_bucket_id?: string;
+    riskBucketId?: string;
     /** Client strategy key carried for compatibility */
-    strategy_key?: string;
+    strategyKey?: string;
     /** Delegated agent ID when submitted through a delegated session */
-    delegation_id?: string;
+    delegationId?: string;
     /** Conditional order ID for an attached take-profit leg */
-    take_profit_order_id?: string;
+    takeProfitOrderId?: string;
     /** Conditional order ID for an attached stop-loss leg */
-    stop_loss_order_id?: string;
+    stopLossOrderId?: string;
 }
 /**
  * Response from cancelling an order.
  */
 export interface CancelOrderResponse {
     /** Order identifier */
-    order_id: string;
+    orderId: string;
     /** Cancellation status */
     status: "SUCCESS" | "FAILED";
     /** Optional response message */
@@ -101,17 +101,17 @@ export interface CancelOrderResponse {
  */
 export interface ReplaceOrderResponse {
     /** New order identifier (after replacement) */
-    order_id: string;
+    orderId: string;
     /** Replace operation status */
     status: "SUCCESS" | "FAILED";
     /** Operation message */
     message: string;
     /** Fields that were updated */
-    updated_fields: UpdatedFields;
+    updatedFields: UpdatedFields;
     /** Original order identifier that was replaced */
-    original_order_id?: string;
+    originalOrderId?: string;
     /** Match result information for the new order */
-    match_result?: MatchResult;
+    matchResult?: MatchResult;
 }
 /**
  * Fields that were updated in the replace operation
@@ -129,15 +129,15 @@ export interface GetPaginatedOrdersParams {
     /** Filter by order status */
     status?: OrderStatus;
     /** Filter by trading pair UUID */
-    trading_pair_id?: string;
+    tradingPairId?: string;
     /** Filter by trading mode */
-    trading_mode?: TradingMode;
+    tradingMode?: TradingMode;
     /** Filter by margin account UUID */
-    margin_account_id?: string;
+    marginAccountId?: string;
     /** Page number for pagination (default: 1) */
     page?: number;
     /** Number of orders per page (default: 10, max: 100) */
-    page_size?: number;
+    pageSize?: number;
 }
 /**
  * Response from getting paginated orders
@@ -155,9 +155,9 @@ export interface GetPaginatedOrdersResponse {
     /** Current page number */
     page: number;
     /** Number of orders per page */
-    page_size: number;
+    pageSize: number;
     /** Total number of pages */
-    total_pages: number;
+    totalPages: number;
 }
 /**
  * Response from getting a single order by ID
@@ -182,9 +182,9 @@ export interface BatchCancelError {
  */
 export interface BatchCancelResult {
     /** Order identifier */
-    order_id: string;
+    orderId: string;
     /** Timestamp when the order was canceled (ISO 8601 format) */
-    cancelled_at?: string;
+    cancelledAt?: string;
     /** Error details if the cancellation failed */
     error?: BatchCancelError;
 }
@@ -193,11 +193,11 @@ export interface BatchCancelResult {
  */
 export interface BatchCancelOrdersResponse {
     /** Total number of orders requested to cancel */
-    total_requested: number;
+    totalRequested: number;
     /** Total number of orders successfully canceled */
-    total_cancelled: number;
+    totalCancelled: number;
     /** Total number of orders that failed to cancel */
-    total_failed: number;
+    totalFailed: number;
     /** Individual results for each order */
     results: BatchCancelResult[];
 }
@@ -215,9 +215,9 @@ export interface BatchError {
  */
 export interface BatchCreateResult {
     /** Order identifier (empty string if creation failed before ID assignment) */
-    order_id: string;
+    orderId: string;
     /** Match result information if the order was processed */
-    match_result?: MatchResult;
+    matchResult?: MatchResult;
     /** Error details if the creation failed */
     error?: BatchError;
 }
@@ -226,11 +226,11 @@ export interface BatchCreateResult {
  */
 export interface BatchCreateOrdersResponse {
     /** Total number of orders requested to create */
-    total_requested: number;
+    totalRequested: number;
     /** Total number of orders successfully created */
-    total_succeeded: number;
+    totalSucceeded: number;
     /** Total number of orders that failed to create */
-    total_failed: number;
+    totalFailed: number;
     /** Individual results for each order */
     results: BatchCreateResult[];
 }
@@ -239,13 +239,13 @@ export interface BatchCreateOrdersResponse {
  */
 export interface BatchReplaceResult {
     /** Original order identifier */
-    original_order_id: string;
+    originalOrderId: string;
     /** New order identifier (if successful) */
-    new_order_id?: string;
+    newOrderId?: string;
     /** Fields that were updated (if successful) */
-    updated_fields?: UpdatedFields;
+    updatedFields?: UpdatedFields;
     /** Match result information if the new order was processed */
-    match_result?: MatchResult;
+    matchResult?: MatchResult;
     /** Error details if the replacement failed */
     error?: BatchError;
 }
@@ -254,11 +254,11 @@ export interface BatchReplaceResult {
  */
 export interface BatchReplaceOrdersResponse {
     /** Total number of orders requested to replace */
-    total_requested: number;
+    totalRequested: number;
     /** Total number of orders successfully replaced */
-    total_succeeded: number;
+    totalSucceeded: number;
     /** Total number of orders that failed to replace */
-    total_failed: number;
+    totalFailed: number;
     /** Individual results for each order */
     results: BatchReplaceResult[];
 }
@@ -315,49 +315,49 @@ export interface BatchReplaceOrderParams {
     useMasterBalance?: boolean;
 }
 export interface CancelConditionalOrderResponse {
-    conditional_order_id: string;
+    conditionalOrderId: string;
     status: "SUCCESS" | "FAILED";
     message: string;
 }
 export interface ListConditionalOrdersParams {
-    margin_account_id?: string;
-    trading_pair_id?: string;
+    marginAccountId?: string;
+    tradingPairId?: string;
     state?: ConditionalOrderState;
     page?: number;
-    page_size?: number;
+    pageSize?: number;
 }
 export interface ConditionalOrder {
-    conditional_order_id: string;
-    trading_pair_id: string;
-    margin_account_id: string;
-    position_id?: string;
-    parent_order_id?: string;
-    association_type?: "POSITION" | "PARENT_ORDER";
-    linked_group_id?: string;
-    condition_type: ConditionalOrderConditionType;
-    trigger_source: ConditionalOrderTriggerSource;
-    trigger_price: string;
+    conditionalOrderId: string;
+    tradingPairId: string;
+    marginAccountId: string;
+    positionId?: string;
+    parentOrderId?: string;
+    associationType?: "POSITION" | "PARENT_ORDER";
+    linkedGroupId?: string;
+    conditionType: ConditionalOrderConditionType;
+    triggerSource: ConditionalOrderTriggerSource;
+    triggerPrice: string;
     side: OrderSide;
-    position_side: PositionSide;
-    order_type: OrderType;
-    limit_price?: string;
+    positionSide: PositionSide;
+    orderType: OrderType;
+    limitPrice?: string;
     quantity?: string;
-    slippage_tolerance_bps?: number;
-    reduce_only: boolean;
-    time_in_force?: TimeInForce;
+    slippageToleranceBps?: number;
+    reduceOnly: boolean;
+    timeInForce?: TimeInForce;
     state: ConditionalOrderState;
-    triggered_order_id?: string;
-    triggered_at?: string;
-    activated_at?: string;
-    cancelled_at?: string;
-    expires_at?: string;
-    failure_reason?: string;
-    created_at: string;
-    updated_at: string;
+    triggeredOrderId?: string;
+    triggeredAt?: string;
+    activatedAt?: string;
+    cancelledAt?: string;
+    expiresAt?: string;
+    failureReason?: string;
+    createdAt: string;
+    updatedAt: string;
 }
 export interface ListConditionalOrdersResponse {
     orders: ConditionalOrder[];
     total: number;
     page: number;
-    page_size: number;
+    pageSize: number;
 }

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

@@ -4,7 +4,7 @@
 import { z } from "zod";
 export declare const ListMarginAccountsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
     state: z.ZodOptional<z.ZodString>;
     tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
@@ -49,14 +49,14 @@ export declare const TransferCollateralFromParentMarginAccountSchema: z.ZodObjec
 }, z.core.$strip>;
 export declare const GetMarginAccountMovementsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
     marginAccountId: z.ZodUUID;
-    movement_type: z.ZodOptional<z.ZodString>;
+    movementType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GetParentMarginAccountMovementsSchema: z.ZodOptional<z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    movement_type: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    movementType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export declare const SimulateOrderRiskSchema: z.ZodObject<{
     marginAccountId: z.ZodUUID;

package/dist/validation/margin-accounts.js

@@ -5,7 +5,7 @@ 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(),
+    pageSize: 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(),
@@ -54,10 +54,10 @@ export const TransferCollateralFromParentMarginAccountSchema = z.object({
 });
 export const GetMarginAccountMovementsSchema = PaginationSchema.extend({
     marginAccountId: UUIDSchema,
-    movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
+    movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 });
 export const GetParentMarginAccountMovementsSchema = PaginationSchema.extend({
-    movement_type: z.string().trim().min(1, "Movement type cannot be empty").optional(),
+    movementType: z.string().trim().min(1, "Movement type cannot be empty").optional(),
 }).optional();
 const BaseSimulateOrderRiskRequestSchema = z.object({
     tradingPairId: UUIDSchema,

package/dist/validation/market.d.ts

@@ -203,7 +203,7 @@ export declare const GetTradingPairSchema: z.ZodObject<{
  */
 export declare const SearchTradingPairsSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
     page: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**

package/dist/validation/market.js

@@ -214,7 +214,7 @@ export const GetTradingPairSchema = z.object({
  */
 export const SearchTradingPairsSchema = z.object({
     query: z.string().min(1, "Search query cannot be empty").optional(),
-    page_size: z.number().int().min(1).max(100).optional(),
+    pageSize: z.number().int().min(1).max(100).optional(),
     page: z.number().int().min(1).optional(),
 });
 /**

package/dist/validation/positions.d.ts

@@ -4,9 +4,9 @@
 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>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
     status: z.ZodOptional<z.ZodEnum<{
         OPEN: "OPEN";
         CLOSED: "CLOSED";
@@ -86,8 +86,8 @@ export declare const AttachPositionTpSlSchema: z.ZodObject<{
 }, 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>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;

package/dist/validation/positions.js

@@ -5,7 +5,7 @@ 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(),
+    pageSize: 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"',
@@ -17,8 +17,8 @@ const PositionIdSchema = z.object({
     positionId: UUIDSchema,
 });
 export const ListPositionsSchema = PaginationSchema.extend({
-    margin_account_id: UUIDSchema.optional(),
-    trading_pair_id: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
     status: PositionStatusSchema.optional(),
 });
 export const GetPositionSchema = PositionIdSchema;
@@ -91,7 +91,7 @@ export const AttachPositionTpSlSchema = PositionIdSchema.extend({
     }),
 });
 export const ListPositionHistorySchema = PaginationSchema.extend({
-    position_id: UUIDSchema.optional(),
-    margin_account_id: UUIDSchema.optional(),
-    trading_pair_id: UUIDSchema.optional(),
+    positionId: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
+    tradingPairId: UUIDSchema.optional(),
 });

package/dist/validation/profile.d.ts

@@ -36,15 +36,15 @@ export declare const TransactionTypeSchema: z.ZodEnum<{
  */
 export declare const GetUserMovementsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    entry_type: z.ZodOptional<z.ZodEnum<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    entryType: z.ZodOptional<z.ZodEnum<{
         CREDIT: "CREDIT";
         DEBIT: "DEBIT";
         LOCK: "LOCK";
         UNLOCK: "UNLOCK";
         FEE: "FEE";
     }>>;
-    transaction_type: z.ZodOptional<z.ZodEnum<{
+    transactionType: z.ZodOptional<z.ZodEnum<{
         FEE: "FEE";
         DEPOSIT: "DEPOSIT";
         WITHDRAWAL: "WITHDRAWAL";
@@ -54,7 +54,7 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
         INTEREST: "INTEREST";
         REWARD: "REWARD";
     }>>;
-    asset_id: z.ZodOptional<z.ZodUUID>;
+    assetId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 /**
  * Get User Trades validation schema
@@ -64,13 +64,13 @@ export declare const GetUserMovementsSchema: z.ZodObject<{
  */
 export declare const GetUserTradesSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 export declare const ListFundingPaymentsSchema: z.ZodObject<{
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
-    position_id: z.ZodOptional<z.ZodUUID>;
-    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
+    positionId: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;

package/dist/validation/profile.js

@@ -26,10 +26,10 @@ export const TransactionTypeSchema = z.enum(["DEPOSIT", "WITHDRAWAL", "TRADE", "
  */
 export const GetUserMovementsSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
-    entry_type: LedgerEntryTypeSchema.optional(),
-    transaction_type: TransactionTypeSchema.optional(),
-    asset_id: UUIDSchema.optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    entryType: LedgerEntryTypeSchema.optional(),
+    transactionType: TransactionTypeSchema.optional(),
+    assetId: UUIDSchema.optional(),
 });
 /**
  * Get User Trades validation schema
@@ -39,13 +39,13 @@ export const GetUserMovementsSchema = z.object({
  */
 export const GetUserTradesSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
-    trading_pair_id: UUIDSchema.optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    tradingPairId: UUIDSchema.optional(),
 });
 export const ListFundingPaymentsSchema = z.object({
     page: z.number().int("Page must be an integer").min(1, "Page must be at least 1").optional(),
-    page_size: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
-    trading_pair_id: UUIDSchema.optional(),
-    position_id: UUIDSchema.optional(),
-    margin_account_id: UUIDSchema.optional(),
+    pageSize: z.number().int("Page size must be an integer").min(1, "Page size must be at least 1").max(100, "Page size cannot exceed 100").optional(),
+    tradingPairId: UUIDSchema.optional(),
+    positionId: UUIDSchema.optional(),
+    marginAccountId: UUIDSchema.optional(),
 });

package/dist/validation/trading.d.ts

@@ -226,9 +226,9 @@ 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_id: trading pair UUID (optional filter)
+ * - tradingPairId: trading pair UUID (optional filter)
  * - page: number (default: 1)
- * - page_size: number (default: 10, max: 100)
+ * - pageSize: number (default: 10, max: 100)
  */
 export declare const GetPaginatedOrdersSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodEnum<{
@@ -241,14 +241,14 @@ export declare const GetPaginatedOrdersSchema: z.ZodObject<{
         REJECTED: "REJECTED";
         EXPIRED: "EXPIRED";
     }>>;
-    trading_pair_id: z.ZodOptional<z.ZodUUID>;
-    trading_mode: z.ZodOptional<z.ZodEnum<{
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
+    tradingMode: z.ZodOptional<z.ZodEnum<{
         SPOT: "SPOT";
         MARGIN: "MARGIN";
     }>>;
-    margin_account_id: z.ZodOptional<z.ZodUUID>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const ConditionalOrderConditionTypeSchema: z.ZodEnum<{
     STOP_LOSS: "STOP_LOSS";
@@ -274,8 +274,8 @@ 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>;
+    marginAccountId: z.ZodOptional<z.ZodUUID>;
+    tradingPairId: z.ZodOptional<z.ZodUUID>;
     state: z.ZodOptional<z.ZodEnum<{
         CANCELLED: "CANCELLED";
         EXPIRED: "EXPIRED";
@@ -286,7 +286,7 @@ export declare const ListConditionalOrdersSchema: z.ZodObject<{
         FAILED: "FAILED";
     }>>;
     page: z.ZodOptional<z.ZodNumber>;
-    page_size: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Single batch create order item validation schema