@0xmonaco/core 0.8.5 → 0.8.7-develop.0f12336

package/dist/api/profile/api.js

@@ -17,7 +17,7 @@
  * console.log(`User: ${profile.username} (${profile.address})`);
  * ```
  */
-import { GetUserMovementsSchema, GetUserTradesSchema, validate } from "@0xmonaco/types";
+import { GetUserMovementsSchema, GetUserTradesSchema, ListFundingPaymentsSchema, validate } from "@0xmonaco/types";
 import { APIError } from "../../errors";
 import { BaseAPI } from "../base";
 export class ProfileAPIImpl extends BaseAPI {
@@ -40,8 +40,8 @@ export class ProfileAPIImpl extends BaseAPI {
      * console.log(`User ID: ${profile.id}`);
      * console.log(`Address: ${profile.address}`);
      * console.log(`Username: ${profile.username}`);
-     * console.log(`Account type: ${profile.account_type}`);
-     * console.log(`Can withdraw: ${profile.can_withdraw}`);
+     * console.log(`Account type: ${profile.accountType}`);
+     * console.log(`Can withdraw: ${profile.canWithdraw}`);
      * ```
      */
     async getProfile() {
@@ -56,27 +56,27 @@ export class ProfileAPIImpl extends BaseAPI {
      * @param params - Optional query parameters for pagination and filtering
      * @param params.page - Page number (starts from 1, default: 1)
      * @param params.limit - Number of items per page (default: 20, max: 100)
-     * @param params.entry_type - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
-     * @param params.transaction_type - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
-     * @param params.asset_id - Filter by asset ID (UUID)
+     * @param params.entryType - Filter by entry type (CREDIT, DEBIT, LOCK, UNLOCK, FEE)
+     * @param params.transactionType - Filter by transaction type (DEPOSIT, WITHDRAWAL, TRADE, FEE, FUNDING, LIQUIDATION, INTEREST, REWARD)
+     * @param params.assetId - Filter by asset ID (UUID)
      * @returns Promise resolving to paginated movements response
      * @throws {APIError} When the request fails or user is not authenticated
      *
      * @example
      * ```typescript
-     * // Get first page with default page_size (20)
+     * // Get first page with default pageSize (20)
      * const movements = await profileAPI.getPaginatedUserMovements();
      * console.log(`Total movements: ${movements.total}`);
      *
-     * // Get second page with custom page_size
-     * const page2 = await profileAPI.getPaginatedUserMovements({ page: 2, page_size: 50 });
-     * console.log(`Page ${page2.page} of ${page2.total_pages}`);
+     * // Get second page with custom pageSize
+     * const page2 = await profileAPI.getPaginatedUserMovements({ page: 2, pageSize: 50 });
+     * console.log(`Page ${page2.page} of ${page2.totalPages}`);
      *
      * // Filter by entry type and transaction type
-     * const deposits = await profileAPI.getPaginatedUserMovements({ entry_type: "CREDIT", transaction_type: "DEPOSIT" });
+     * const deposits = await profileAPI.getPaginatedUserMovements({ entryType: "CREDIT", transactionType: "DEPOSIT" });
      *
      * // Filter by asset
-     * const usdcMovements = await profileAPI.getPaginatedUserMovements({ asset_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * const usdcMovements = await profileAPI.getPaginatedUserMovements({ assetId: "550e8400-e29b-41d4-a716-446655440000" });
      * ```
      */
     async getPaginatedUserMovements(params) {
@@ -87,17 +87,17 @@ export class ProfileAPIImpl extends BaseAPI {
         if (params?.page !== undefined) {
             searchParams.append("page", params.page.toString());
         }
-        if (params?.page_size !== undefined) {
-            searchParams.append("page_size", params.page_size.toString());
+        if (params?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
-        if (params?.entry_type !== undefined) {
-            searchParams.append("entry_type", params.entry_type);
+        if (params?.entryType !== undefined) {
+            searchParams.append("entryType", params.entryType);
         }
-        if (params?.transaction_type !== undefined) {
-            searchParams.append("transaction_type", params.transaction_type);
+        if (params?.transactionType !== undefined) {
+            searchParams.append("transactionType", params.transactionType);
         }
-        if (params?.asset_id !== undefined) {
-            searchParams.append("asset_id", params.asset_id);
+        if (params?.assetId !== undefined) {
+            searchParams.append("assetId", params.assetId);
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/movements?${queryString}` : "/api/v1/accounts/movements";
@@ -111,7 +111,7 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * @param params - Optional query parameters for pagination
      * @param params.page - Page number (starts from 1, default: 1)
-     * @param params.page_size - Number of items per page (default: 20, max: 100)
+     * @param params.pageSize - Number of items per page (default: 20, max: 100)
      * @returns Promise resolving to paginated balances response
      * @throws {APIError} When the request fails or user is not authenticated
      *
@@ -121,11 +121,11 @@ export class ProfileAPIImpl extends BaseAPI {
      * const balances = await profileAPI.getUserBalances();
      * console.log(`Total balances: ${balances.total}`);
      * balances.balances.forEach(balance => {
-     *   console.log(`${balance.symbol}: ${balance.available_balance}`);
+     *   console.log(`${balance.symbol}: ${balance.availableBalance}`);
      * });
      *
      * // Get page 2 with 50 items per page
-     * const nextBalances = await profileAPI.getUserBalances({ page: 2, page_size: 50 });
+     * const nextBalances = await profileAPI.getUserBalances({ page: 2, pageSize: 50 });
      * console.log(`Returned ${nextBalances.balances.length} balances`);
      * ```
      */
@@ -134,8 +134,8 @@ export class ProfileAPIImpl extends BaseAPI {
         if (params?.page !== undefined) {
             searchParams.append("page", params.page.toString());
         }
-        if (params?.page_size !== undefined) {
-            searchParams.append("page_size", params.page_size.toString());
+        if (params?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/balances?${queryString}` : "/api/v1/accounts/balances";
@@ -144,7 +144,7 @@ export class ProfileAPIImpl extends BaseAPI {
     /**
      * Get the current user's balance for a specific asset.
      *
-     * Fetches the user's balance for a specific asset from the /api/v1/accounts/balances/{asset_id} endpoint.
+     * Fetches the user's balance for a specific asset from the /api/v1/accounts/balances/{assetId} endpoint.
      * Requires a valid access token to be set. If no balance exists for a valid asset, returns zero balances.
      *
      * @param assetId - The asset identifier (UUID)
@@ -155,15 +155,15 @@ export class ProfileAPIImpl extends BaseAPI {
      * ```typescript
      * // Get balance for a specific asset
      * const balance = await profileAPI.getUserBalanceByAssetId('123e4567-e89b-12d3-a456-426614174000');
-     * console.log(`${balance.symbol}: ${balance.available_balance}`);
-     * console.log(`Locked: ${balance.locked_balance}`);
-     * console.log(`Total: ${balance.total_balance}`);
+     * console.log(`${balance.symbol}: ${balance.availableBalance}`);
+     * console.log(`Locked: ${balance.lockedBalance}`);
+     * console.log(`Total: ${balance.totalBalance}`);
      * ```
      */
     async getUserBalanceByAssetId(assetId) {
         if (!assetId || assetId.trim() === "") {
             throw new APIError("assetId is required and cannot be empty", {
-                endpoint: "/api/v1/accounts/balances/{asset_id}",
+                endpoint: "/api/v1/accounts/balances/{assetId}",
             });
         }
         const url = `/api/v1/accounts/balances/${assetId}`;
@@ -184,7 +184,7 @@ export class ProfileAPIImpl extends BaseAPI {
      * const stats = await profileAPI.getPortfolioStats("30d");
      * console.log(`PnL: ${stats.pnl}`);
      * console.log(`Volume: ${stats.volume}`);
-     * console.log(`Total equity: ${stats.total_equity}`);
+     * console.log(`Total equity: ${stats.totalEquity}`);
      * ```
      */
     async getPortfolioStats(period) {
@@ -222,8 +222,8 @@ export class ProfileAPIImpl extends BaseAPI {
      *
      * @param params - Optional query parameters for pagination and filtering
      * @param params.page - Page number (starts from 1, default: 1)
-     * @param params.page_size - Number of items per page (default: 20, max: 100)
-     * @param params.trading_pair_id - Filter by trading pair ID (UUID)
+     * @param params.pageSize - Number of items per page (default: 20, max: 100)
+     * @param params.tradingPairId - Filter by trading pair ID (UUID)
      * @returns Promise resolving to paginated trades response
      * @throws {ValidationError} When the provided params fail client-side validation
      * @throws {APIError} When the request fails or user is not authenticated
@@ -235,7 +235,7 @@ export class ProfileAPIImpl extends BaseAPI {
      * console.log(`Total trades: ${trades.total}`);
      *
      * // Filter by trading pair
-     * const pairTrades = await profileAPI.getUserTrades({ trading_pair_id: "550e8400-e29b-41d4-a716-446655440000" });
+     * const pairTrades = await profileAPI.getUserTrades({ tradingPairId: "550e8400-e29b-41d4-a716-446655440000" });
      * ```
      */
     async getUserTrades(params) {
@@ -246,14 +246,54 @@ export class ProfileAPIImpl extends BaseAPI {
         if (params?.page !== undefined) {
             searchParams.append("page", params.page.toString());
         }
-        if (params?.page_size !== undefined) {
-            searchParams.append("page_size", params.page_size.toString());
+        if (params?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
         }
-        if (params?.trading_pair_id !== undefined) {
-            searchParams.append("trading_pair_id", params.trading_pair_id);
+        if (params?.tradingPairId !== undefined) {
+            searchParams.append("tradingPairId", params.tradingPairId);
         }
         const queryString = searchParams.toString();
         const url = queryString ? `/api/v1/accounts/trades?${queryString}` : "/api/v1/accounts/trades";
         return await this.makeAuthenticatedRequest(url);
     }
+    /**
+     * List the current user's funding payment history with pagination and filters.
+     *
+     * Fetches funding payments from the /api/v1/accounts/funding-payments endpoint.
+     * Requires a valid access token to be set.
+     *
+     * @param params - Optional query parameters for pagination and filtering
+     * @returns Promise resolving to paginated funding payments response
+     * @throws {APIError} When the request fails or user is not authenticated
+     *
+     * @example
+     * ```typescript
+     * const funding = await profileAPI.listFundingPayments({ tradingPairId: "550e8400-e29b-41d4-a716-446655440000" });
+     * console.log(`Total funding payments: ${funding.total}`);
+     * ```
+     */
+    async listFundingPayments(params) {
+        if (params) {
+            validate(ListFundingPaymentsSchema, params);
+        }
+        const searchParams = new URLSearchParams();
+        if (params?.page !== undefined) {
+            searchParams.append("page", params.page.toString());
+        }
+        if (params?.pageSize !== undefined) {
+            searchParams.append("pageSize", params.pageSize.toString());
+        }
+        if (params?.tradingPairId !== undefined) {
+            searchParams.append("tradingPairId", params.tradingPairId);
+        }
+        if (params?.positionId !== undefined) {
+            searchParams.append("positionId", params.positionId);
+        }
+        if (params?.marginAccountId !== undefined) {
+            searchParams.append("marginAccountId", params.marginAccountId);
+        }
+        const queryString = searchParams.toString();
+        const url = queryString ? `/api/v1/accounts/funding-payments?${queryString}` : "/api/v1/accounts/funding-payments";
+        return await this.makeAuthenticatedRequest(url);
+    }
 }

package/dist/api/sub-accounts/api.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Sub-Accounts API Implementation
+ *
+ * Manage a master account's sub-accounts and their per-asset spending limits.
+ * All methods are session-authenticated. The limit mutations (`createLimit`,
+ * `updateLimit`, `deleteLimit`) additionally require the master account to hold
+ * the `ManageSubAccounts` permission — enforced server-side, so a non-master or
+ * unpermissioned caller receives a 403.
+ *
+ * @example
+ * ```typescript
+ * const { subAccounts } = await sdk.subAccounts.list();
+ * await sdk.subAccounts.createLimit({ subAccountId, assetId, maxAmount: "1000.00" });
+ * ```
+ */
+import type { CreateSubAccountLimitRequest, CreateSubAccountLimitResponse, GetSubAccountLimitsResponse, ListSubAccountsResponse, SubAccountsAPI, UpdateSubAccountLimitBody, UpdateSubAccountLimitResponse } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class SubAccountsAPIImpl extends BaseAPI implements SubAccountsAPI {
+    /**
+     * Lists the authenticated master account's sub-accounts with balances.
+     *
+     * @returns Promise resolving to the sub-accounts and total count
+     */
+    list(): Promise<ListSubAccountsResponse>;
+    /**
+     * Creates a per-asset spending limit on a sub-account.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param body - Sub-account, asset, max amount, and optional daily limit
+     * @returns Promise resolving to the created limit
+     */
+    createLimit(body: CreateSubAccountLimitRequest): Promise<CreateSubAccountLimitResponse>;
+    /**
+     * Gets the limits configured for a sub-account.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @returns Promise resolving to the sub-account's limits
+     */
+    getLimits(subAccountId: string): Promise<GetSubAccountLimitsResponse>;
+    /**
+     * Updates a sub-account's per-asset limit (partial update).
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @param body - Fields to update
+     * @returns Promise resolving to the updated limit
+     */
+    updateLimit(subAccountId: string, assetId: string, body: UpdateSubAccountLimitBody): Promise<UpdateSubAccountLimitResponse>;
+    /**
+     * Deletes a sub-account's per-asset limit.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @returns Promise resolving when the limit is deleted
+     */
+    deleteLimit(subAccountId: string, assetId: string): Promise<void>;
+}

package/dist/api/sub-accounts/api.js

@@ -0,0 +1,80 @@
+/**
+ * Sub-Accounts API Implementation
+ *
+ * Manage a master account's sub-accounts and their per-asset spending limits.
+ * All methods are session-authenticated. The limit mutations (`createLimit`,
+ * `updateLimit`, `deleteLimit`) additionally require the master account to hold
+ * the `ManageSubAccounts` permission — enforced server-side, so a non-master or
+ * unpermissioned caller receives a 403.
+ *
+ * @example
+ * ```typescript
+ * const { subAccounts } = await sdk.subAccounts.list();
+ * await sdk.subAccounts.createLimit({ subAccountId, assetId, maxAmount: "1000.00" });
+ * ```
+ */
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
+export class SubAccountsAPIImpl extends BaseAPI {
+    /**
+     * Lists the authenticated master account's sub-accounts with balances.
+     *
+     * @returns Promise resolving to the sub-accounts and total count
+     */
+    async list() {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.list());
+    }
+    /**
+     * Creates a per-asset spending limit on a sub-account.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param body - Sub-account, asset, max amount, and optional daily limit
+     * @returns Promise resolving to the created limit
+     */
+    async createLimit(body) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.createLimit(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Gets the limits configured for a sub-account.
+     *
+     * @param subAccountId - Sub-account UUID
+     * @returns Promise resolving to the sub-account's limits
+     */
+    async getLimits(subAccountId) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.getLimits(subAccountId));
+    }
+    /**
+     * Updates a sub-account's per-asset limit (partial update).
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @param body - Fields to update
+     * @returns Promise resolving to the updated limit
+     */
+    async updateLimit(subAccountId, assetId, body) {
+        return await this.makeAuthenticatedRequest(perpRoutes.subAccounts.limit(subAccountId, assetId), {
+            method: "PUT",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Deletes a sub-account's per-asset limit.
+     *
+     * Requires the `ManageSubAccounts` permission (enforced server-side).
+     *
+     * @param subAccountId - Sub-account UUID
+     * @param assetId - Asset UUID
+     * @returns Promise resolving when the limit is deleted
+     */
+    async deleteLimit(subAccountId, assetId) {
+        await this.makeAuthenticatedRequest(perpRoutes.subAccounts.limit(subAccountId, assetId), {
+            method: "DELETE",
+        });
+    }
+}

package/dist/api/sub-accounts/index.d.ts

@@ -0,0 +1 @@
+export { SubAccountsAPIImpl } from "./api";

package/dist/api/sub-accounts/index.js

@@ -0,0 +1 @@
+export { SubAccountsAPIImpl } from "./api";

package/dist/api/trades/api.d.ts

@@ -1,22 +1,25 @@
 import type { TradeEvent } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
- * Raw trade event from the API (snake_case) - matches websocket structure
+ * Raw trade event from the API (camelCase wire shape).
  */
 interface RawTradeEvent {
-    event_type: string;
-    trading_pair_id: string;
-    trading_mode: string;
+    eventType: string;
+    tradingPairId: string;
+    tradingMode: string;
     data: {
-        trade_id: string;
+        tradeId: string;
         price: string;
         quantity: string;
-        maker_side: string;
-        executed_at: string;
+        /** Raw (integer) quantity; present on single-trade lookups, ignored when mapping */
+        quantityRaw?: string;
+        makerSide: string;
+        /** Absent when the trade has no recorded execution time */
+        executedAt?: string;
     };
 }
 /**
- * Convert a raw trade event (snake_case) to a TradeEvent (camelCase)
+ * Convert a raw wire trade event to an ergonomic TradeEvent.
  */
 export declare function parseRawTradeEvent(raw: RawTradeEvent): TradeEvent;
 /**
@@ -26,7 +29,7 @@ export interface GetTradesOptions {
     /** Page number (starts from 1, default: 1) */
     page?: number;
     /** Maximum number of records to return (default: 25, max: 100) */
-    page_size?: number;
+    pageSize?: number;
 }
 /**
  * Trades API for fetching historical trade data
@@ -37,8 +40,16 @@ export declare class TradesAPIImpl extends BaseAPI {
      *
      * @param tradingPairId - The trading pair UUID
      * @param options - Pagination options
-     * @returns Array of TradeEvent records sorted by executed_at descending (newest first)
+     * @returns Array of TradeEvent records sorted by executedAt descending (newest first)
      */
     getTrades(tradingPairId: string, options?: GetTradesOptions): Promise<TradeEvent[]>;
+    /**
+     * Get a single trade by its UUID.
+     *
+     * @param tradeId - The trade UUID
+     * @returns The matching TradeEvent
+     * @throws {APIError} If the trade is not found
+     */
+    getTradeById(tradeId: string): Promise<TradeEvent>;
 }
 export {};

package/dist/api/trades/api.js

@@ -1,18 +1,19 @@
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp";
 /**
- * Convert a raw trade event (snake_case) to a TradeEvent (camelCase)
+ * Convert a raw wire trade event to an ergonomic TradeEvent.
  */
 export function parseRawTradeEvent(raw) {
     return {
         eventType: "trade",
-        tradingPairId: raw.trading_pair_id,
-        tradingMode: raw.trading_mode.toUpperCase(),
+        tradingPairId: raw.tradingPairId,
+        tradingMode: raw.tradingMode.toUpperCase(),
         data: {
-            tradeId: raw.data.trade_id,
+            tradeId: raw.data.tradeId,
             price: raw.data.price,
             quantity: raw.data.quantity,
-            makerSide: raw.data.maker_side.toUpperCase(),
-            executedAt: raw.data.executed_at,
+            makerSide: raw.data.makerSide.toUpperCase(),
+            executedAt: raw.data.executedAt ?? "",
         },
     };
 }
@@ -25,18 +26,29 @@ export class TradesAPIImpl extends BaseAPI {
      *
      * @param tradingPairId - The trading pair UUID
      * @param options - Pagination options
-     * @returns Array of TradeEvent records sorted by executed_at descending (newest first)
+     * @returns Array of TradeEvent records sorted by executedAt descending (newest first)
      */
     async getTrades(tradingPairId, options = {}) {
         const { page = 1 } = options;
-        // Ensure page_size is a positive number between 1 and 100, defaulting to 25
-        const page_size = options.page_size != null && options.page_size > 0 ? Math.min(options.page_size, 100) : 25;
+        // Ensure pageSize is a positive number between 1 and 100, defaulting to 25
+        const pageSize = options.pageSize != null && options.pageSize > 0 ? Math.min(options.pageSize, 100) : 25;
         const params = new URLSearchParams();
         if (page > 1) {
             params.set("page", String(page));
         }
-        params.set("page_size", String(page_size));
+        params.set("pageSize", String(pageSize));
         const response = await this.makePublicRequest(`/api/v1/trades/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return response.trades.map(parseRawTradeEvent);
     }
+    /**
+     * Get a single trade by its UUID.
+     *
+     * @param tradeId - The trade UUID
+     * @returns The matching TradeEvent
+     * @throws {APIError} If the trade is not found
+     */
+    async getTradeById(tradeId) {
+        const response = await this.makePublicRequest(perpRoutes.trades.byId(tradeId));
+        return parseRawTradeEvent(response);
+    }
 }

package/dist/api/trading/api.d.ts

@@ -21,7 +21,7 @@
  * );
  * ```
  */
-import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateConditionalOrderParams, CreateConditionalOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
+import type { BatchCancelOrdersResponse, BatchCreateOrderParams, BatchCreateOrdersResponse, BatchReplaceOrderParams, BatchReplaceOrdersResponse, CancelConditionalOrderResponse, CancelOrderResponse, CreateOrderResponse, GetOrderResponse, GetPaginatedOrdersParams, GetPaginatedOrdersResponse, ListConditionalOrdersParams, ListConditionalOrdersResponse, OrderSide, ParentTpSlLegParams, PositionSide, ReplaceOrderResponse, TimeInForce, TradingAPI, TradingMode } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
     /**
@@ -80,6 +80,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         expirationDate?: string;
         timeInForce?: TimeInForce;
         marginAccountId?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -132,6 +134,8 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
         tradingMode?: TradingMode;
         slippageTolerance?: number;
         marginAccountId?: string;
+        riskBucketId?: string;
+        riskBucketCollateral?: string;
         strategyKey?: string;
         positionSide?: PositionSide;
         leverage?: string;
@@ -156,7 +160,6 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * ```
      */
     cancelOrder(orderId: string): Promise<CancelOrderResponse>;
-    createConditionalOrder(params: CreateConditionalOrderParams): Promise<CreateConditionalOrderResponse>;
     cancelConditionalOrder(conditionalOrderId: string): Promise<CancelConditionalOrderResponse>;
     listConditionalOrders(params?: ListConditionalOrdersParams): Promise<ListConditionalOrdersResponse>;
     /**
@@ -259,9 +262,9 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      *
      * @param params - Query parameters for filtering orders
      * @param params.status - Filter by order status (e.g., "SUBMITTED", "FILLED") (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 (defaults to 1, must be > 0)
-     * @param params.page_size - Number of orders per page (defaults to 10, max 100, must be > 0)
+     * @param params.pageSize - Number of orders per page (defaults to 10, max 100, must be > 0)
      * @returns Promise resolving to GetPaginatedOrdersResponse with orders and pagination info
      * @throws {APIError} When API communication fails
      *
@@ -270,13 +273,13 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * // Get submitted orders for a specific trading pair with custom pagination
      * const orders = await tradingAPI.getPaginatedOrders({
      *   status: "SUBMITTED",
-     *   trading_pair_id: "456e7890-e12b-12d3-a456-426614174000",
+     *   tradingPairId: "456e7890-e12b-12d3-a456-426614174000",
      *   page: 1,
-     *   page_size: 20
+     *   pageSize: 20
      * });
      * console.log(`Found ${orders.total} orders, showing page ${orders.page}`);
      *
-     * // Get all orders with default pagination (page=1, page_size=10)
+     * // Get all orders with default pagination (page=1, pageSize=10)
      * const allOrders = await tradingAPI.getPaginatedOrders();
      * ```
      */
@@ -296,7 +299,7 @@ export declare class TradingAPIImpl extends BaseAPI implements TradingAPI {
      * // Get order details by ID
      * const orderDetails = await tradingAPI.getOrder("order_123");
      * console.log(`Order status: ${orderDetails.order.status}`);
-     * console.log(`Remaining quantity: ${orderDetails.order.remaining_quantity}`);
+     * console.log(`Remaining quantity: ${orderDetails.order.remainingQuantity}`);
      * ```
      */
     getOrder(orderId: string): Promise<GetOrderResponse>;