@0xmonaco/types 0.0.0-develop-20260120180031

package/dist/trading/orders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders.js","sourceRoot":"","sources":["../../src/trading/orders.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/trading/responses.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Trading Response Types
+ *
+ * Response types for trading operations.
+ */
+import type { Order, OrderStatus } from "./orders";
+/**
+ * Match result information for order execution.
+ * Contains detailed information about trades, fills, and execution quality.
+ *
+ * @remarks
+ * This structure is returned after an order is processed by the matching engine,
+ * providing details about how the order was executed, including fills, slippage,
+ * and final order status.
+ */
+export interface MatchResult {
+    /** Number of trades executed during matching */
+    trades_count: number;
+    /** Total quantity filled across all trades (in base currency) */
+    total_filled: string;
+    /** Remaining unfilled quantity after immediate matches (in base currency) */
+    remaining_quantity: string;
+    /** Average fill price across all trades (null if no fills occurred) */
+    average_fill_price: 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;
+    /** Maximum slippage allowed when order was submitted in basis points (null if not set) */
+    max_slippage_bps: number | null;
+    /** Price range across executed trades (null if no fills) */
+    execution_price_range: {
+        /** Best (most favorable) execution price achieved */
+        best_price: string;
+        /** Worst (least favorable) execution price achieved */
+        worst_price: string;
+    } | null;
+}
+/**
+ * Response from creating an order.
+ *
+ * @remarks
+ * Contains the order ID, operation status, and optional match result
+ * with details about immediate fills that occurred during order placement.
+ */
+export interface CreateOrderResponse {
+    /** Created order identifier (UUID) */
+    order_id: 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;
+}
+/**
+ * Response from cancelling an order.
+ */
+export interface CancelOrderResponse {
+    /** Order identifier */
+    order_id: string;
+    /** Cancellation status */
+    status: "SUCCESS" | "FAILED";
+    /** Optional response message */
+    message?: string;
+}
+/**
+ * Response from replacing an order.
+ */
+export interface ReplaceOrderResponse {
+    /** New order identifier (after replacement) */
+    order_id: string;
+    /** Replace operation status */
+    status: "SUCCESS" | "FAILED";
+    /** Operation message */
+    message: string;
+    /** Fields that were updated */
+    updated_fields: UpdatedFields;
+    /** Original order identifier that was replaced */
+    original_order_id?: string;
+    /** Match result information for the new order */
+    match_result?: MatchResult;
+}
+/**
+ * Fields that were updated in the replace operation
+ */
+export interface UpdatedFields {
+    /** Updated price (if changed) */
+    price?: string;
+    /** Updated quantity (if changed) */
+    quantity?: string;
+}
+/**
+ * Query parameters for getting paginated orders
+ */
+export interface GetPaginatedOrdersParams {
+    /** Filter by order status */
+    status?: OrderStatus;
+    /** Filter by trading pair */
+    trading_pair?: string;
+    /** Page number for pagination (default: 1) */
+    page?: number;
+    /** Number of orders per page (default: 10, max: 100) */
+    page_size?: number;
+}
+/**
+ * Response from getting paginated orders
+ */
+export interface GetPaginatedOrdersResponse {
+    /** Array of orders */
+    orders: Order[];
+    /** Total number of orders matching the query */
+    total: number;
+    /** Current page number */
+    page: number;
+    /** Number of orders per page */
+    page_size: number;
+    /** Total number of pages */
+    total_pages: number;
+}
+/**
+ * Response from getting a single order by ID
+ */
+export interface GetOrderResponse {
+    /** Order data */
+    order: Order;
+    /** Request status */
+    status: "SUCCESS" | "FAILED";
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/trading/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../src/trading/responses.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEnD;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,+EAA+E;IAC/E,MAAM,EAAE,WAAW,CAAC;IACpB,6FAA6F;IAC7F,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,0FAA0F;IAC1F,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,4DAA4D;IAC5D,qBAAqB,EAAE;QACrB,qDAAqD;QACrD,UAAU,EAAE,MAAM,CAAC;QACnB,uDAAuD;QACvD,WAAW,EAAE,MAAM,CAAC;KACrB,GAAG,IAAI,CAAC;CACV;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,sFAAsF;IACtF,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,uBAAuB;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,gCAAgC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,cAAc,EAAE,aAAa,CAAC;IAC9B,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,YAAY,CAAC,EAAE,WAAW,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,6BAA6B;IAC7B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6BAA6B;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,sBAAsB;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB;IACjB,KAAK,EAAE,KAAK,CAAC;IACb,qBAAqB;IACrB,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;CAC9B"}

package/dist/trading/responses.js

@@ -0,0 +1,7 @@
+/**
+ * Trading Response Types
+ *
+ * Response types for trading operations.
+ */
+export {};
+//# sourceMappingURL=responses.js.map

package/dist/trading/responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.js","sourceRoot":"","sources":["../../src/trading/responses.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/validation/common.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Common Validation Utilities
+ *
+ * Shared utilities for runtime validation across all SDK modules.
+ * These utilities work with any Zod schema and provide consistent
+ * error handling throughout the SDK.
+ */
+import type { z } from "zod";
+/**
+ * Validation error class for user-friendly error messages.
+ *
+ * Wraps Zod validation errors to provide better error formatting and
+ * structured error access for API consumers. This error is thrown when
+ * validation fails on any SDK parameters.
+ *
+ * **Features:**
+ * - Human-readable error message with field paths
+ * - Access to raw Zod issues for detailed error handling
+ * - Structured error object via `getErrors()` method
+ *
+ * **Example Usage:**
+ * ```typescript
+ * import { validate, PlaceLimitOrderSchema } from '@0xmonaco/types';
+ *
+ * try {
+ *   const validated = validate(PlaceLimitOrderSchema, {
+ *     tradingPairId: "invalid-uuid",
+ *     side: "BUY",
+ *     quantity: "-10", // Invalid: negative
+ *     price: "100"
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     // Human-readable message
+ *     console.log(error.message);
+ *     // "Validation failed:
+ *     //   - tradingPairId: Invalid uuid
+ *     //   - quantity: Number must be greater than 0"
+ *
+ *     // Structured errors for form validation
+ *     const errors = error.getErrors();
+ *     console.log(errors);
+ *     // {
+ *     //   "tradingPairId": "Invalid uuid",
+ *     //   "quantity": "Number must be greater than 0"
+ *     // }
+ *
+ *     // Raw Zod issues for advanced handling
+ *     console.log(error.issues);
+ *     // [{ path: ["tradingPairId"], message: "Invalid uuid", ... }, ...]
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link validate} - Helper function that throws ValidationError
+ */
+export declare class ValidationError extends Error {
+    /**
+     * Array of Zod validation issues containing detailed error information.
+     * Each issue includes the field path, error code, and message.
+     */
+    readonly issues: z.ZodIssue[];
+    /**
+     * Creates a new ValidationError from a Zod validation error.
+     *
+     * Automatically formats all validation issues into a human-readable
+     * message and stores the raw issues for programmatic access.
+     *
+     * @param zodError - The Zod validation error to wrap
+     *
+     * @example
+     * ```typescript
+     * const result = schema.safeParse(data);
+     * if (!result.success) {
+     *   throw new ValidationError(result.error);
+     * }
+     * ```
+     */
+    constructor(zodError: z.ZodError);
+    /**
+     * Get validation errors as a structured object for easy field-level error display.
+     *
+     * Converts the array of Zod issues into a simple key-value object where
+     * keys are field paths (dot-notation) and values are error messages.
+     * Root-level errors (no path) are stored under the "root" key.
+     *
+     * **Use Cases:**
+     * - Form validation (map errors to input fields)
+     * - API error responses (structured JSON)
+     * - Error aggregation and reporting
+     *
+     * @returns Object mapping field paths to error messages
+     *
+     * @example
+     * ```typescript
+     * // Single field error
+     * error.getErrors();
+     * // { "price": "Number must be greater than 0" }
+     *
+     * // Multiple field errors
+     * error.getErrors();
+     * // {
+     * //   "tradingPairId": "Invalid uuid",
+     * //   "quantity": "Required",
+     * //   "options.timeInForce": "Invalid enum value"
+     * // }
+     *
+     * // Root-level error (no specific field)
+     * error.getErrors();
+     * // { "root": "At least one field is required" }
+     *
+     * // Use in React form
+     * const errors = validationError.getErrors();
+     * <input error={errors.price} />
+     * ```
+     */
+    getErrors(): Record<string, string>;
+}
+/**
+ * Validates data against a Zod schema and throws user-friendly errors on failure.
+ *
+ * This is a convenience wrapper around Zod's `safeParse` that automatically
+ * throws a {@link ValidationError} with formatted error messages when validation fails.
+ *
+ * **When to Use:**
+ * - Validating user input before API calls
+ * - Runtime type checking for dynamic data
+ * - Ensuring data integrity before processing
+ *
+ * **Error Handling:**
+ * On validation failure, throws {@link ValidationError} which provides:
+ * - Human-readable error message
+ * - Structured errors via `getErrors()`
+ * - Raw Zod issues for advanced handling
+ *
+ * @template T - The expected type after validation
+ * @param schema - Zod schema to validate against
+ * @param data - Data to validate (unknown type for safety)
+ * @returns Validated and typed data
+ * @throws {@link ValidationError} When validation fails
+ *
+ * @example
+ * ```typescript
+ * import { validate, PlaceLimitOrderSchema } from '@0xmonaco/types';
+ *
+ * // Basic validation
+ * try {
+ *   const validatedOrder = validate(PlaceLimitOrderSchema, userInput);
+ *   // validatedOrder is now typed and guaranteed valid
+ *   await sdk.trading.placeLimitOrder(...validatedOrder);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     // Show user-friendly errors
+ *     console.error(error.message);
+ *     const fieldErrors = error.getErrors();
+ *     // Display errors next to form fields
+ *   }
+ * }
+ *
+ * // With custom error handling
+ * function safeValidate<T>(schema: z.ZodSchema<T>, data: unknown) {
+ *   try {
+ *     return { success: true, data: validate(schema, data) };
+ *   } catch (error) {
+ *     if (error instanceof ValidationError) {
+ *       return { success: false, errors: error.getErrors() };
+ *     }
+ *     throw error; // Re-throw unexpected errors
+ *   }
+ * }
+ *
+ * const result = safeValidate(PlaceLimitOrderSchema, input);
+ * if (result.success) {
+ *   // Use result.data
+ * } else {
+ *   // Handle result.errors
+ * }
+ * ```
+ */
+export declare function validate<T>(schema: z.ZodSchema<T>, data: unknown): T;
+//# sourceMappingURL=common.d.ts.map

package/dist/validation/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/validation/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;;OAGG;IACH,SAAgB,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IAErC;;;;;;;;;;;;;;;OAeG;gBACS,QAAQ,EAAE,CAAC,CAAC,QAAQ;IAWhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAQpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAQpE"}

package/dist/validation/common.js

@@ -0,0 +1,196 @@
+/**
+ * Common Validation Utilities
+ *
+ * Shared utilities for runtime validation across all SDK modules.
+ * These utilities work with any Zod schema and provide consistent
+ * error handling throughout the SDK.
+ */
+/**
+ * Validation error class for user-friendly error messages.
+ *
+ * Wraps Zod validation errors to provide better error formatting and
+ * structured error access for API consumers. This error is thrown when
+ * validation fails on any SDK parameters.
+ *
+ * **Features:**
+ * - Human-readable error message with field paths
+ * - Access to raw Zod issues for detailed error handling
+ * - Structured error object via `getErrors()` method
+ *
+ * **Example Usage:**
+ * ```typescript
+ * import { validate, PlaceLimitOrderSchema } from '@0xmonaco/types';
+ *
+ * try {
+ *   const validated = validate(PlaceLimitOrderSchema, {
+ *     tradingPairId: "invalid-uuid",
+ *     side: "BUY",
+ *     quantity: "-10", // Invalid: negative
+ *     price: "100"
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     // Human-readable message
+ *     console.log(error.message);
+ *     // "Validation failed:
+ *     //   - tradingPairId: Invalid uuid
+ *     //   - quantity: Number must be greater than 0"
+ *
+ *     // Structured errors for form validation
+ *     const errors = error.getErrors();
+ *     console.log(errors);
+ *     // {
+ *     //   "tradingPairId": "Invalid uuid",
+ *     //   "quantity": "Number must be greater than 0"
+ *     // }
+ *
+ *     // Raw Zod issues for advanced handling
+ *     console.log(error.issues);
+ *     // [{ path: ["tradingPairId"], message: "Invalid uuid", ... }, ...]
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link validate} - Helper function that throws ValidationError
+ */
+export class ValidationError extends Error {
+    /**
+     * Creates a new ValidationError from a Zod validation error.
+     *
+     * Automatically formats all validation issues into a human-readable
+     * message and stores the raw issues for programmatic access.
+     *
+     * @param zodError - The Zod validation error to wrap
+     *
+     * @example
+     * ```typescript
+     * const result = schema.safeParse(data);
+     * if (!result.success) {
+     *   throw new ValidationError(result.error);
+     * }
+     * ```
+     */
+    constructor(zodError) {
+        const messages = zodError.issues.map((issue) => {
+            const path = issue.path.join(".");
+            return `${path ? `${path}: ` : ""}${issue.message}`;
+        });
+        super(`Validation failed:\n  - ${messages.join("\n  - ")}`);
+        this.name = "ValidationError";
+        this.issues = zodError.issues;
+    }
+    /**
+     * Get validation errors as a structured object for easy field-level error display.
+     *
+     * Converts the array of Zod issues into a simple key-value object where
+     * keys are field paths (dot-notation) and values are error messages.
+     * Root-level errors (no path) are stored under the "root" key.
+     *
+     * **Use Cases:**
+     * - Form validation (map errors to input fields)
+     * - API error responses (structured JSON)
+     * - Error aggregation and reporting
+     *
+     * @returns Object mapping field paths to error messages
+     *
+     * @example
+     * ```typescript
+     * // Single field error
+     * error.getErrors();
+     * // { "price": "Number must be greater than 0" }
+     *
+     * // Multiple field errors
+     * error.getErrors();
+     * // {
+     * //   "tradingPairId": "Invalid uuid",
+     * //   "quantity": "Required",
+     * //   "options.timeInForce": "Invalid enum value"
+     * // }
+     *
+     * // Root-level error (no specific field)
+     * error.getErrors();
+     * // { "root": "At least one field is required" }
+     *
+     * // Use in React form
+     * const errors = validationError.getErrors();
+     * <input error={errors.price} />
+     * ```
+     */
+    getErrors() {
+        const errors = {};
+        for (const issue of this.issues) {
+            const path = issue.path.join(".");
+            errors[path || "root"] = issue.message;
+        }
+        return errors;
+    }
+}
+/**
+ * Validates data against a Zod schema and throws user-friendly errors on failure.
+ *
+ * This is a convenience wrapper around Zod's `safeParse` that automatically
+ * throws a {@link ValidationError} with formatted error messages when validation fails.
+ *
+ * **When to Use:**
+ * - Validating user input before API calls
+ * - Runtime type checking for dynamic data
+ * - Ensuring data integrity before processing
+ *
+ * **Error Handling:**
+ * On validation failure, throws {@link ValidationError} which provides:
+ * - Human-readable error message
+ * - Structured errors via `getErrors()`
+ * - Raw Zod issues for advanced handling
+ *
+ * @template T - The expected type after validation
+ * @param schema - Zod schema to validate against
+ * @param data - Data to validate (unknown type for safety)
+ * @returns Validated and typed data
+ * @throws {@link ValidationError} When validation fails
+ *
+ * @example
+ * ```typescript
+ * import { validate, PlaceLimitOrderSchema } from '@0xmonaco/types';
+ *
+ * // Basic validation
+ * try {
+ *   const validatedOrder = validate(PlaceLimitOrderSchema, userInput);
+ *   // validatedOrder is now typed and guaranteed valid
+ *   await sdk.trading.placeLimitOrder(...validatedOrder);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     // Show user-friendly errors
+ *     console.error(error.message);
+ *     const fieldErrors = error.getErrors();
+ *     // Display errors next to form fields
+ *   }
+ * }
+ *
+ * // With custom error handling
+ * function safeValidate<T>(schema: z.ZodSchema<T>, data: unknown) {
+ *   try {
+ *     return { success: true, data: validate(schema, data) };
+ *   } catch (error) {
+ *     if (error instanceof ValidationError) {
+ *       return { success: false, errors: error.getErrors() };
+ *     }
+ *     throw error; // Re-throw unexpected errors
+ *   }
+ * }
+ *
+ * const result = safeValidate(PlaceLimitOrderSchema, input);
+ * if (result.success) {
+ *   // Use result.data
+ * } else {
+ *   // Handle result.errors
+ * }
+ * ```
+ */
+export function validate(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        throw new ValidationError(result.error);
+    }
+    return result.data;
+}
+//# sourceMappingURL=common.js.map

package/dist/validation/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/validation/common.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAOxC;;;;;;;;;;;;;;;OAeG;IACH,YAAY,QAAoB;QAC9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YAC7C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,2BAA2B,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,SAAS;QACP,MAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC;QACzC,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,UAAU,QAAQ,CAAI,MAAsB,EAAE,IAAa;IAC/D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAEtC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC"}

package/dist/validation/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validation Schemas
+ *
+ * Runtime validation using Zod for all SDK inputs.
+ * Catches errors before making API calls.
+ *
+ * **Shared Utilities:**
+ * - {@link ValidationError} - User-friendly validation error class
+ * - {@link validate} - Helper function for schema validation
+ *
+ * **Schema Modules:**
+ * - Trading schemas (orders, trading pairs)
+ * - Vault schemas (deposits, withdrawals)
+ * - Market schemas (trading pairs, candlesticks)
+ */
+export * from "./common.js";
+export * from "./market.js";
+export * from "./trading.js";
+export * from "./vault.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,cAAc,aAAa,CAAC;AAE5B,cAAc,aAAa,CAAC;AAE5B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/validation/index.js

@@ -0,0 +1,22 @@
+/**
+ * Validation Schemas
+ *
+ * Runtime validation using Zod for all SDK inputs.
+ * Catches errors before making API calls.
+ *
+ * **Shared Utilities:**
+ * - {@link ValidationError} - User-friendly validation error class
+ * - {@link validate} - Helper function for schema validation
+ *
+ * **Schema Modules:**
+ * - Trading schemas (orders, trading pairs)
+ * - Vault schemas (deposits, withdrawals)
+ * - Market schemas (trading pairs, candlesticks)
+ */
+// Export validation utilities
+export * from "./common.js";
+export * from "./market.js";
+// Export module-specific schemas
+export * from "./trading.js";
+export * from "./vault.js";
+//# sourceMappingURL=index.js.map

package/dist/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,8BAA8B;AAC9B,cAAc,aAAa,CAAC;AAE5B,cAAc,aAAa,CAAC;AAC5B,iCAAiC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}