@0xmonaco/types 0.7.7 → 0.7.8

package/dist/validation/trading.js

@@ -0,0 +1,313 @@
+/**
+ * Trading API Validation Schemas
+ *
+ * Zod schemas for validating trading API inputs before making requests.
+ * Provides clear, actionable error messages for invalid parameters.
+ */
+import { z } from "zod";
+import { ORDER_STATUS_VALUES } from "../trading/orders";
+/**
+ * Order side validation
+ */
+export const OrderSideSchema = z.enum(["BUY", "SELL"], {
+    message: 'Order side must be "BUY" or "SELL"',
+});
+/**
+ * Trading mode validation
+ */
+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)
+ */
+export const PositiveDecimalStringSchema = z
+    .string()
+    .trim()
+    .min(1, "Value cannot be empty")
+    .regex(/^\d+(\.\d+)?$/, "Value must be a positive decimal number (e.g., '1.5', '100')")
+    .refine((val) => Number.parseFloat(val) > 0, {
+    message: "Value must be greater than 0",
+});
+/**
+ * UUID validation
+ */
+export const UUIDSchema = z.uuid({
+    message: "Must be a valid UUID (e.g., '123e4567-e89b-12d3-a456-426614174000')",
+});
+/**
+ * ISO 8601 date string validation
+ */
+export const ISO8601DateSchema = z.iso.datetime({
+    message: "Must be a valid ISO 8601 date string (e.g., '2024-12-31T23:59:59Z')",
+});
+/**
+ * Slippage tolerance validation (0 to 1, where 0.01 = 1%)
+ */
+export const SlippageToleranceSchema = z
+    .number()
+    .min(0, "Slippage tolerance must be at least 0 (no slippage)")
+    .max(1, "Slippage tolerance cannot exceed 1 (100%)")
+    .optional();
+/**
+ * Place Limit Order validation schema
+ */
+export const PlaceLimitOrderSchema = z
+    .object({
+    tradingPairId: UUIDSchema,
+    side: OrderSideSchema,
+    quantity: PositiveDecimalStringSchema,
+    price: PositiveDecimalStringSchema,
+    options: z
+        .object({
+        tradingMode: TradingModeSchema.optional(),
+        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({
+    tradingPairId: UUIDSchema,
+    side: OrderSideSchema,
+    quantity: PositiveDecimalStringSchema,
+    options: z
+        .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
+ */
+export const CancelOrderSchema = z.object({
+    orderId: UUIDSchema,
+});
+/**
+ * Replace Order validation schema
+ *
+ * Validates parameters for replacing an existing order.
+ * Matches the replaceOrder method signature which accepts:
+ * - orderId: string (UUID)
+ * - newOrder: { price?: string, quantity?: string, useMasterBalance?: boolean }
+ */
+export const ReplaceOrderSchema = z.object({
+    orderId: UUIDSchema,
+    newOrder: z.object({
+        price: PositiveDecimalStringSchema.optional(),
+        quantity: PositiveDecimalStringSchema.optional(),
+        useMasterBalance: z.boolean().optional(),
+    }),
+});
+/**
+ * Get Paginated Orders validation schema
+ *
+ * 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)
+ * - 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_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(),
+});
+/**
+ * Order type validation
+ */
+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
+ *
+ * Validates each order in a batch create request.
+ * - LIMIT orders require a price
+ * - MARKET orders must not have a price
+ */
+export const BatchCreateOrderItemSchema = z
+    .object({
+    tradingPairId: UUIDSchema,
+    orderType: OrderTypeSchema,
+    side: OrderSideSchema,
+    price: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema,
+    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",
+    path: ["price"],
+})
+    .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
+ *
+ * Validates the full array of orders for a batch create request.
+ */
+export const BatchCreateOrdersSchema = z.object({
+    orders: z.array(BatchCreateOrderItemSchema).min(1, "At least one order is required"),
+});
+/**
+ * Single batch replace order item validation schema
+ *
+ * Validates each order in a batch replace request.
+ * At least one of price or quantity must be provided.
+ */
+export const BatchReplaceOrderItemSchema = z
+    .object({
+    orderId: UUIDSchema,
+    price: PositiveDecimalStringSchema.optional(),
+    quantity: PositiveDecimalStringSchema.optional(),
+    useMasterBalance: z.boolean().optional(),
+})
+    .refine((data) => data.price !== undefined || data.quantity !== undefined, {
+    message: "At least one of price or quantity must be provided",
+});
+/**
+ * Batch Replace Orders validation schema
+ *
+ * Validates the full array of orders for a batch replace request.
+ */
+export const BatchReplaceOrdersSchema = z.object({
+    orders: z.array(BatchReplaceOrderItemSchema).min(1, "At least one order is required"),
+});

package/dist/validation/vault.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Vault API Validation Schemas
+ */
+import { z } from "zod";
+/**
+ * Ethereum address validation
+ */
+export declare const AddressSchema: z.ZodString;
+/**
+ * Positive BigInt validation
+ *
+ * Accepts either:
+ * - A positive integer string (e.g., "1000000000000000000" for 1 token with 18 decimals)
+ * - A positive bigint value (e.g., 1000000000000000000n)
+ *
+ * This flexibility allows validation of:
+ * - User input (strings from forms)
+ * - Parsed amounts (bigint from parseUnits())
+ *
+ * @example
+ * ```typescript
+ * // String input (from user)
+ * validate(PositiveBigIntStringSchema, "1000000");
+ *
+ * // BigInt input (from parseUnits)
+ * import { parseUnits } from 'viem';
+ * const amount = parseUnits("1.0", 18); // 1000000000000000000n
+ * validate(PositiveBigIntStringSchema, amount);
+ * ```
+ */
+export declare const PositiveBigIntStringSchema: z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>;
+/**
+ * Approve Token validation schema
+ */
+export declare const ApproveTokenSchema: z.ZodObject<{
+    assetId: z.ZodUUID;
+    amount: z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>;
+    autoWait: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Deposit validation schema
+ */
+export declare const DepositSchema: z.ZodObject<{
+    assetId: z.ZodUUID;
+    amount: z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>;
+    autoWait: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Withdraw validation schema.
+ *
+ * The SDK calls the gateway to allocate the `withdrawalIndex` and obtain
+ * pre-signed calldata, then submits that calldata via the connected wallet.
+ * `autoWait` controls whether the SDK awaits on-chain confirmation.
+ */
+export declare const WithdrawSchema: z.ZodObject<{
+    assetId: z.ZodUUID;
+    amount: z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>;
+    destination: z.ZodString;
+    autoWait: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Get Balance validation schema
+ */
+export declare const GetBalanceSchema: z.ZodObject<{
+    assetId: z.ZodUUID;
+}, z.core.$strip>;

package/dist/validation/vault.js

@@ -0,0 +1,79 @@
+/**
+ * Vault API Validation Schemas
+ */
+import { z } from "zod";
+import { UUIDSchema } from "./trading";
+/**
+ * Ethereum address validation
+ */
+export const AddressSchema = z.string().regex(/^0x[a-fA-F0-9]{40}$/, {
+    message: "Must be a valid Ethereum address (e.g., '0x1234...5678')",
+});
+/**
+ * Positive BigInt validation
+ *
+ * Accepts either:
+ * - A positive integer string (e.g., "1000000000000000000" for 1 token with 18 decimals)
+ * - A positive bigint value (e.g., 1000000000000000000n)
+ *
+ * This flexibility allows validation of:
+ * - User input (strings from forms)
+ * - Parsed amounts (bigint from parseUnits())
+ *
+ * @example
+ * ```typescript
+ * // String input (from user)
+ * validate(PositiveBigIntStringSchema, "1000000");
+ *
+ * // BigInt input (from parseUnits)
+ * import { parseUnits } from 'viem';
+ * const amount = parseUnits("1.0", 18); // 1000000000000000000n
+ * validate(PositiveBigIntStringSchema, amount);
+ * ```
+ */
+export const PositiveBigIntStringSchema = z.union([
+    z
+        .string()
+        .regex(/^\d+$/, "Must be a positive integer string")
+        .refine((val) => BigInt(val) > 0n, {
+        message: "Amount must be greater than 0",
+    }),
+    z.bigint().refine((val) => val > 0n, {
+        message: "Amount must be greater than 0",
+    }),
+]);
+/**
+ * Approve Token validation schema
+ */
+export const ApproveTokenSchema = z.object({
+    assetId: UUIDSchema,
+    amount: PositiveBigIntStringSchema,
+    autoWait: z.boolean().optional(),
+});
+/**
+ * Deposit validation schema
+ */
+export const DepositSchema = z.object({
+    assetId: UUIDSchema,
+    amount: PositiveBigIntStringSchema,
+    autoWait: z.boolean().optional(),
+});
+/**
+ * Withdraw validation schema.
+ *
+ * The SDK calls the gateway to allocate the `withdrawalIndex` and obtain
+ * pre-signed calldata, then submits that calldata via the connected wallet.
+ * `autoWait` controls whether the SDK awaits on-chain confirmation.
+ */
+export const WithdrawSchema = z.object({
+    assetId: UUIDSchema,
+    amount: PositiveBigIntStringSchema,
+    destination: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "destination must be a 0x-prefixed 20-byte hex address"),
+    autoWait: z.boolean().optional(),
+});
+/**
+ * Get Balance validation schema
+ */
+export const GetBalanceSchema = z.object({
+    assetId: UUIDSchema,
+});

package/dist/vault/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Vault Types
+ *
+ * Types for vault operations including deposits, withdrawals, and balance management.
+ */
+import type { BaseAPI } from "../api/index";
+import type { Balance, TransactionResult, WithdrawResult } from "./responses";
+/**
+ * Vault API interface.
+ * Provides methods for managing token deposits and withdrawals.
+ * Handles token approvals and balance management.
+ */
+export interface VaultAPI extends BaseAPI {
+    /**
+     * Approves the vault to spend tokens.
+     * @param assetId - Asset identifier (UUID) to approve
+     * @param amount - Amount to approve
+     * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @returns Promise resolving to the transaction result
+     */
+    approve(assetId: string, amount: bigint, autoWait?: boolean): Promise<TransactionResult>;
+    /**
+     * Deposits tokens into the vault.
+     * @param assetId - Asset identifier (UUID) to deposit
+     * @param amount - Amount to deposit
+     * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @returns Promise resolving to the transaction result
+     */
+    deposit(assetId: string, amount: bigint, autoWait?: boolean): Promise<TransactionResult>;
+    /**
+     * Initiates a withdrawal: allocates a `withdrawalIndex` via the API Gateway,
+     * receives pre-signed calldata for `executeSignedWithdrawal(...)`, and
+     * submits it on-chain through the connected wallet.
+     *
+     * @param assetId - Asset identifier (UUID) to withdraw
+     * @param amount - Raw token amount (smallest unit, as bigint)
+     * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @returns Promise resolving to `{ withdrawalIndex, transaction }`
+     */
+    withdraw(assetId: string, amount: bigint, autoWait?: boolean): Promise<WithdrawResult>;
+    /**
+     * Retries a previously-initiated withdrawal whose on-chain submission never
+     * landed (wallet rejected, page reloaded before receipt, stuck mempool).
+     * Re-fetches the same signed calldata and resubmits via the connected wallet
+     * — does NOT initiate a new withdrawal.
+     *
+     * @param withdrawalIndex - Index returned by the original `withdraw()` call
+     * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
+     */
+    retryWithdrawal(withdrawalIndex: number, autoWait?: boolean): Promise<WithdrawResult>;
+    /**
+     * Gets the balance of a token in the vault.
+     * @param assetId - Asset identifier (UUID) to check
+     * @returns Promise resolving to the balance
+     * @deprecated This method is no longer supported and will throw an APIError (410 Gone). Use `profileAPI.getUserBalances()` or `profileAPI.getUserBalanceByAssetId()` instead.
+     */
+    getBalance(assetId: string): Promise<Balance>;
+    /**
+     * Gets the allowance for a token.
+     * @param assetId - Asset identifier (UUID) to check
+     * @returns Promise resolving to the allowance
+     */
+    getAllowance(assetId: string): Promise<bigint>;
+    /**
+     * Checks if a token needs approval for an amount.
+     * @param assetId - Asset identifier (UUID) to check
+     * @param amount - Amount to check
+     * @returns Promise resolving to whether approval is needed
+     */
+    needsApproval(assetId: string, amount: bigint): Promise<boolean>;
+    /**
+     * Gets the address of the vault.
+     * @returns Promise resolving to the address of the vault
+     */
+    getVaultAddress(): Promise<string>;
+    /**
+     * Sets the wallet client for signing transactions.
+     * Used when the wallet becomes available after SDK initialization.
+     * @param walletClient - The wallet client to set
+     */
+    setWalletClient(walletClient: unknown): void;
+}
+export type { Balance, TransactionResult, WithdrawResult } from "./responses";

package/dist/vault/index.js

@@ -0,0 +1,5 @@
+/**
+ * Vault Types
+ *
+ * Types for vault operations including deposits, withdrawals, and balance management.
+ */

package/dist/vault/responses.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Vault Response Types
+ *
+ * Response types for vault operations.
+ */
+/**
+ * Response from a transaction.
+ */
+export interface TransactionResult {
+    /** Transaction hash */
+    hash: string;
+    /** Transaction status */
+    status: "pending" | "confirmed" | "failed";
+    /** Nonce used for this operation */
+    nonce: bigint;
+    /** Transaction receipt (only available when autoWait is enabled) */
+    receipt?: import("viem").TransactionReceipt;
+}
+/**
+ * Result of initiating a withdrawal.
+ *
+ * The API gateway allocates a `withdrawalIndex` via the matching engine and
+ * returns pre-signed calldata for the vault contract's
+ * `executeSignedWithdrawal(...)` function. The SDK submits that calldata on
+ * behalf of the connected wallet — the user is the on-chain caller, but the
+ * `WITHDRAWAL_SIGNER` signature embedded in the calldata is what the contract
+ * authenticates against.
+ *
+ * Extends [`TransactionResult`] so callers can read `hash`, `status`, `nonce`
+ * (and `receipt` when `autoWait` is true) directly off the result, just like
+ * `approve` / `deposit`.
+ */
+export interface WithdrawResult extends TransactionResult {
+    /** Allocated withdrawal index — matches `executeSignedWithdrawal.index`. */
+    withdrawalIndex: number;
+}
+/**
+ * Token balance information.
+ */
+export interface Balance {
+    /** Token address */
+    token: string;
+    /** Balance amount */
+    amount: bigint;
+    /** Formatted balance string */
+    formatted: string;
+    /** Token symbol */
+    symbol: string;
+    /** Token decimals */
+    decimals: number;
+}

package/dist/vault/responses.js

@@ -0,0 +1,5 @@
+/**
+ * Vault Response Types
+ *
+ * Response types for vault operations.
+ */

package/dist/websocket/base.d.ts

@@ -0,0 +1,31 @@
+/**
+ * WebSocket Types
+ *
+ * Types for the functional Monaco WebSocket client.
+ */
+/**
+ * WebSocket connection status
+ */
+export type WebSocketStatus = "connected" | "connecting" | "disconnected" | "reconnecting";
+/**
+ * Raw event message interface
+ * This is the raw message received from the backend
+ */
+export interface RawEventMessage {
+    /** Channel name */
+    channel: string;
+    /** Event data */
+    data: unknown;
+    /** Event type */
+    type: string;
+}
+/**
+ * Base error event that can be used across different components
+ */
+export interface BaseErrorEvent {
+    type: string;
+    message: string;
+    timestamp: number;
+    code?: string | number;
+    details?: unknown;
+}

package/dist/websocket/base.js

@@ -0,0 +1,5 @@
+/**
+ * WebSocket Types
+ *
+ * Types for the functional Monaco WebSocket client.
+ */

package/dist/websocket/clients/orderbook-client.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Orderbook Types
+ */
+/**
+ * Quotation mode for orderbook subscription.
+ *
+ * - "BASE": Prices are displayed in the quote currency per unit of the base currency.
+ *   For example, for the BTC/USD market, prices are shown as USD per BTC.
+ * - "QUOTE": Prices are displayed in the base currency per unit of the quote currency.
+ *   For example, for the BTC/USD market, prices are shown as BTC per USD.
+ *
+ * Choose the mode based on how you want to interpret price levels in the orderbook.
+ */
+export type OrderbookQuotationMode = "BASE" | "QUOTE";

package/dist/websocket/clients/orderbook-client.js

@@ -0,0 +1,3 @@
+/**
+ * Orderbook Types
+ */