@0xmonaco/types 0.4.1 → 0.5.0

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 { 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,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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 "./trading.js";
+export * from "./vault.js";
+export * from "./market.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;AAG5B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,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 module-specific schemas
+export * from "./trading.js";
+export * from "./vault.js";
+export * from "./market.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,iCAAiC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/validation/market.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Market API Validation Schemas
+ */
+import { z } from "zod";
+/**
+ * Candlestick interval validation
+ */
+export declare const IntervalSchema: z.ZodEnum<{
+    "1m": "1m";
+    "5m": "5m";
+    "15m": "15m";
+    "1h": "1h";
+    "4h": "4h";
+    "1d": "1d";
+    "30m": "30m";
+    "1w": "1w";
+    "1M": "1M";
+}>;
+/**
+ * Timestamp validation (milliseconds since epoch)
+ *
+ * Validates that the timestamp is:
+ * - A positive integer
+ * - At least Jan 1, 2000 (catches seconds vs milliseconds errors)
+ * - Within JavaScript's safe integer range
+ * - Not unreasonably far in the future (max 1 year ahead)
+ *
+ * **Why these bounds matter:**
+ * - Prevents typos (e.g., using seconds instead of milliseconds: 1609459200 vs 1609459200000)
+ * - Catches date calculation errors (e.g., Date.now() * 1000 instead of Date.now())
+ * - Ensures timestamps won't cause precision issues in JavaScript
+ *
+ * @example
+ * ```typescript
+ * // Valid timestamps (milliseconds)
+ * validate(TimestampSchema, 1609459200000);  // Jan 1, 2021 ✅
+ * validate(TimestampSchema, Date.now());      // Current time ✅
+ * validate(TimestampSchema, Date.now() + 86400000);  // Tomorrow ✅
+ *
+ * // Invalid timestamps
+ * validate(TimestampSchema, 1609459200);      // Seconds instead of ms (Jan 19, 1970) ❌
+ * validate(TimestampSchema, Date.now() * 1000);  // Way too large ❌
+ * validate(TimestampSchema, 9999999999999999);   // Far future (year 2286) ❌
+ * validate(TimestampSchema, 100000);          // Too old (Jan 1, 1970) ❌
+ * ```
+ */
+export declare const TimestampSchema: z.ZodNumber;
+/**
+ * Get Candlesticks validation schema (by trading pair ID)
+ *
+ * Validates parameters for fetching candlestick (OHLCV) data using a trading pair UUID.
+ * Ensures that the time range is valid by checking that startTime < endTime.
+ *
+ * @example
+ * ```typescript
+ * // Valid request
+ * validate(GetCandlesticksSchema, {
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
+ *   interval: "1h",
+ *   startTime: 1609459200000,  // Jan 1, 2021
+ *   endTime: 1640995200000      // Jan 1, 2022
+ * });
+ *
+ * // Invalid: backwards time range
+ * validate(GetCandlesticksSchema, {
+ *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
+ *   interval: "1h",
+ *   startTime: 1640995200000,  // Jan 1, 2022
+ *   endTime: 1609459200000      // Jan 1, 2021
+ * });
+ * // ValidationError: startTime must be less than endTime
+ * ```
+ */
+export declare const GetCandlesticksSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+    interval: z.ZodEnum<{
+        "1m": "1m";
+        "5m": "5m";
+        "15m": "15m";
+        "1h": "1h";
+        "4h": "4h";
+        "1d": "1d";
+        "30m": "30m";
+        "1w": "1w";
+        "1M": "1M";
+    }>;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Trading pair symbol validation
+ *
+ * Validates trading pair symbols like "BTC/USDT", "ETH/USD", etc.
+ * Symbol format: BASE/QUOTE where:
+ * - BASE and QUOTE are 1-10 alphanumeric characters
+ * - Separated by a forward slash
+ *
+ * @example
+ * ```typescript
+ * // Valid symbols
+ * validate(TradingPairSymbolSchema, "BTC/USDT");   ✅
+ * validate(TradingPairSymbolSchema, "ETH/USD");    ✅
+ * validate(TradingPairSymbolSchema, "MTK/USDCo");  ✅
+ *
+ * // Invalid symbols
+ * validate(TradingPairSymbolSchema, "BTC");        ❌ Missing quote token
+ * validate(TradingPairSymbolSchema, "BTC-USDT");   ❌ Wrong separator
+ * validate(TradingPairSymbolSchema, "/USDT");      ❌ Missing base token
+ * ```
+ */
+export declare const TradingPairSymbolSchema: z.ZodString;
+/**
+ * Get Candlesticks By Symbol validation schema
+ *
+ * Validates parameters for fetching candlestick (OHLCV) data using a trading pair symbol.
+ * This is the schema used by the actual API endpoint which accepts symbols like "BTC/USDT".
+ * Ensures that the time range is valid by checking that startTime < endTime.
+ *
+ * @example
+ * ```typescript
+ * // Valid request
+ * validate(GetCandlesticksBySymbolSchema, {
+ *   symbol: "BTC/USDT",
+ *   interval: "1h",
+ *   startTime: 1609459200000,  // Jan 1, 2021
+ *   endTime: 1640995200000      // Jan 1, 2022
+ * });
+ *
+ * // Invalid: backwards time range
+ * validate(GetCandlesticksBySymbolSchema, {
+ *   symbol: "ETH/USD",
+ *   interval: "1h",
+ *   startTime: 1640995200000,  // Jan 1, 2022
+ *   endTime: 1609459200000      // Jan 1, 2021
+ * });
+ * // ValidationError: startTime must be less than endTime
+ * ```
+ */
+export declare const GetCandlesticksBySymbolSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    interval: z.ZodEnum<{
+        "1m": "1m";
+        "5m": "5m";
+        "15m": "15m";
+        "1h": "1h";
+        "4h": "4h";
+        "1d": "1d";
+        "30m": "30m";
+        "1w": "1w";
+        "1M": "1M";
+    }>;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Get Trading Pair validation schema
+ */
+export declare const GetTradingPairSchema: z.ZodObject<{
+    tradingPairId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Search Trading Pairs validation schema
+ */
+export declare const SearchTradingPairsSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+//# sourceMappingURL=market.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"market.d.ts","sourceRoot":"","sources":["../../src/validation/market.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;EAEzB,CAAC;AAkBH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,aAcxB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;iBAU9B,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,uBAAuB,aAKhC,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAUtC,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC"}