@0xmonaco/types 0.7.6 → 0.7.7

package/dist/validation/trading.js

@@ -1,313 +0,0 @@
-/**
- * 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

@@ -1,66 +0,0 @@
-/**
- * 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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-/**
- * 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

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

package/dist/vault/responses.d.ts

@@ -1,51 +0,0 @@
-/**
- * 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

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

package/dist/websocket/base.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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

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

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

@@ -1,14 +0,0 @@
-/**
- * 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

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