@pipsend/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1194 @@
+/**
+ * WebSocket configuration options
+ */
+interface WebSocketConfig {
+    /** Enable WebSocket connection (default: false) */
+    enabled?: boolean;
+    /** WebSocket endpoint path (default: '/ws') */
+    path?: string;
+    /** Auto-connect on client creation (default: false) */
+    autoConnect?: boolean;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Maximum reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Heartbeat interval in milliseconds (default: 30000) */
+    heartbeatInterval?: number;
+}
+/**
+ * WebSocket message structure
+ */
+interface WebSocketMessage {
+    type: string;
+    payload?: any;
+    timestamp?: number;
+}
+/**
+ * Real-time price update
+ */
+interface PriceUpdate {
+    symbol: string;
+    bid: number;
+    ask: number;
+    spread: number;
+    timestamp: number;
+}
+/**
+ * Real-time order update
+ */
+interface OrderUpdate {
+    orderId: string;
+    symbol: string;
+    status: 'pending' | 'filled' | 'partial' | 'cancelled' | 'rejected';
+    type: 'buy' | 'sell';
+    volume: number;
+    filledVolume: number;
+    price?: number;
+    openTime: number;
+    closeTime?: number;
+    timestamp: number;
+}
+/**
+ * Real-time position update
+ */
+interface PositionUpdate {
+    positionId: string;
+    symbol: string;
+    type: 'buy' | 'sell';
+    volume: number;
+    openPrice: number;
+    currentPrice: number;
+    profit: number;
+    profitPercentage: number;
+    timestamp: number;
+}
+/**
+ * Account balance update
+ */
+interface BalanceUpdate {
+    balance: number;
+    equity: number;
+    margin: number;
+    freeMargin: number;
+    marginLevel: number;
+    timestamp: number;
+}
+/**
+ * WebSocket event types
+ */
+type WebSocketEventType = 'price' | 'order' | 'position' | 'balance' | 'connected' | 'disconnected' | 'error' | 'authenticated' | '*';
+/**
+ * WebSocket event callback
+ */
+type WebSocketCallback<T = any> = (data: T) => void;
+
+/**
+ * Common types used across the API
+ */
+interface PaginationParams {
+    page?: number;
+    per_page?: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    meta: {
+        current_page: number;
+        per_page: number;
+        total: number;
+        total_pages: number;
+    };
+}
+
+/**
+ * Account types
+ */
+interface Account {
+    login: number;
+    email: string;
+    first_name: string;
+    last_name: string;
+    middle_name?: string;
+    company?: string;
+    state: 'active' | 'inactive' | 'archived';
+    balance: number;
+    credit: number;
+    leverage: number;
+    phone?: string;
+    city?: string;
+    address?: string;
+    zip_code?: string;
+    country: string;
+    trading_group: string;
+    created_at: string;
+    updated_at: string;
+}
+interface AccountsListParams extends PaginationParams {
+    /** Single login or comma-separated logins */
+    login?: string | number;
+    /** Single state or comma-separated states (active, inactive, archived) */
+    state?: string;
+    /** Single country or comma-separated countries */
+    country?: string;
+    /** Trading group name */
+    trading_group?: string;
+    /** Email or partial email search */
+    email?: string;
+    /** Search in login, first_name, last_name, email */
+    search?: string;
+    /** Minimum balance */
+    min_balance?: number;
+    /** Maximum balance */
+    max_balance?: number;
+    /** Minimum credit */
+    min_credit?: number;
+    /** Maximum credit */
+    max_credit?: number;
+}
+interface AccountStatistics {
+    total_accounts: number;
+    active_accounts: number;
+    inactive_accounts: number;
+    archived_accounts?: number;
+    total_balance: number;
+    total_credit: number;
+    average_balance: number;
+    by_country?: Array<{
+        country: string;
+        count: number;
+        total_balance: number;
+    }>;
+    by_trading_group?: Array<{
+        trading_group: string;
+        count: number;
+        total_balance: number;
+    }>;
+}
+interface AccountStatisticsParams {
+    /** Filter by country */
+    country?: string;
+    /** Filter by state */
+    state?: string;
+    /** Filter by trading group */
+    trading_group?: string;
+}
+interface ChangePasswordRequest {
+    new_password: string;
+}
+
+/**
+ * Trading Group types
+ */
+interface TradingGroup {
+    name: string;
+    company: string;
+    type: string;
+    is_demo: boolean;
+    currency: string;
+    leverage: number;
+    margin_call: number;
+    stop_out: number;
+    created_at: string;
+    updated_at: string;
+}
+interface TradingGroupsListParams {
+    type?: string;
+    is_demo?: boolean;
+    search?: string;
+}
+interface TradingGroupStatistics {
+    total_groups: number;
+    demo_groups: number;
+    real_groups: number;
+    by_type: Record<string, number>;
+}
+
+/**
+ * Market data types
+ */
+interface Candle {
+    symbol: string;
+    timeframe: string;
+    timestamp: string;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+interface CandlesParams extends PaginationParams {
+    /** Symbol names (comma-separated) - REQUIRED */
+    symbol: string;
+    /** Timeframes: 1m, 5m, 15m, 1h, 4h, 1d (comma-separated) - REQUIRED */
+    timeframe: string;
+    /** Start date (ISO 8601) */
+    from?: string;
+    /** End date (ISO 8601, max: now - 1h) */
+    to?: string;
+    /** Minimum volume */
+    min_volume?: number;
+    /** Maximum volume */
+    max_volume?: number;
+    /** Minimum price (close) */
+    min_price?: number;
+    /** Maximum price (close) */
+    max_price?: number;
+    /** Sort field: timestamp, volume, close (default: timestamp) */
+    sort?: string;
+    /** Sort order: asc, desc (default: desc) */
+    order?: 'asc' | 'desc';
+    /** Limit results (max: 10000, ignores pagination) */
+    limit?: number;
+}
+interface Symbol {
+    name: string;
+    display_name: string;
+    description: string;
+    group_path: string;
+    type: string;
+    is_active: boolean;
+    has_data: boolean;
+    timeframes: string[];
+    first_candle?: string;
+    last_candle?: string;
+}
+interface SymbolsParams extends PaginationParams {
+    /** Symbol names (comma-separated) */
+    name?: string;
+    /** Group codes (comma-separated) */
+    group?: string;
+    /** Symbol types (comma-separated) */
+    type?: string;
+    /** General search (name, code, description) */
+    search?: string;
+    /** Filter by active state (default: true) */
+    is_active?: boolean;
+    /** Filter symbols with available data */
+    has_data?: boolean;
+    /** Sort field: name, group_path, type, created_at (default: name) */
+    sort?: string;
+    /** Sort order: asc, desc (default: asc) */
+    order?: 'asc' | 'desc';
+}
+interface Group {
+    code: string;
+    name: string;
+    path: string;
+    level: number;
+    is_active: boolean;
+    order: number;
+    symbol_count: number;
+}
+interface GroupsParams {
+    /** Group codes (comma-separated) */
+    code?: string;
+    /** Full paths (exact or partial, comma-separated) */
+    path?: string;
+    /** General search (code, name) */
+    search?: string;
+    /** Filter by active state */
+    is_active?: boolean;
+    /** Filter by hierarchy level (0 = root) */
+    level?: number;
+    /** Only root groups (level 0) */
+    root_only?: boolean;
+    /** Sort field: path, code, order, symbol_count (default: path) */
+    sort?: string;
+    /** Sort order: asc, desc (default: asc) */
+    order?: 'asc' | 'desc';
+}
+
+/**
+ * Position types
+ */
+interface Position {
+    id: number;
+    login: number;
+    symbol: string;
+    type: 'buy' | 'sell';
+    volume: number;
+    entry_price: number;
+    current_price: number;
+    profit: number;
+    commission: number;
+    swap: number;
+    net_profit: number;
+    stop_loss?: number;
+    take_profit?: number;
+    opened_at: string;
+    updated_at: string;
+    state: 'open' | 'closed';
+}
+interface PositionsListParams extends PaginationParams {
+    /** Position IDs (comma-separated) */
+    id?: string;
+    /** Account logins (comma-separated) */
+    login?: string;
+    /** Symbols (comma-separated, e.g., "EURUSD,GBPUSD") */
+    symbol?: string;
+    /** Position types: "buy", "sell" (comma-separated) */
+    type?: string;
+    /** Position states: "open", "closed" (comma-separated) */
+    state?: string;
+    /** Opened from date (RFC3339) */
+    opened_from?: string;
+    /** Opened to date (RFC3339) */
+    opened_to?: string;
+    /** Updated from date (RFC3339) */
+    updated_from?: string;
+    /** Updated to date (RFC3339) */
+    updated_to?: string;
+    /** Minimum profit */
+    profit_min?: number;
+    /** Maximum profit */
+    profit_max?: number;
+    /** Minimum volume */
+    volume_min?: number;
+    /** Maximum volume */
+    volume_max?: number;
+    /** Include deleted positions (default: false) */
+    include_deleted?: boolean;
+    /** Sort by field (default: "id") */
+    sort_by?: string;
+    /** Sort order: "asc", "desc" (default: "desc") */
+    sort_order?: 'asc' | 'desc';
+}
+interface PositionStatsParams {
+    /** Account logins (comma-separated) */
+    login?: string;
+    /** Symbols (comma-separated) */
+    symbol?: string;
+    /** Position types: "buy", "sell" (comma-separated) */
+    type?: string;
+    /** Position states: "open", "closed" (comma-separated) */
+    state?: string;
+    /** Opened from date (RFC3339) */
+    opened_from?: string;
+    /** Opened to date (RFC3339) */
+    opened_to?: string;
+    /** Group by: "login", "symbol", "type", "state" */
+    group_by?: string;
+}
+interface PositionStatistics {
+    total_positions: number;
+    total_volume: number;
+    total_profit: number;
+    total_commission: number;
+    total_swap: number;
+    avg_profit: number;
+    max_profit: number;
+    min_profit: number;
+}
+interface PositionStatisticsGrouped {
+    group_key: string;
+    total_positions: number;
+    total_volume: number;
+    total_profit: number;
+    avg_profit: number;
+}
+interface PositionTotalsParams {
+    /** Account logins (comma-separated) */
+    login?: string;
+    /** Symbols (comma-separated) */
+    symbol?: string;
+    /** Position types: "buy", "sell" (comma-separated) */
+    type?: string;
+    /** Position states: "open", "closed" (comma-separated) */
+    state?: string;
+    /** Group by (required): "login", "symbol", "type", "state" */
+    group_by: string;
+}
+interface PositionTotals {
+    group_key: string;
+    count: number;
+    total_volume: number;
+    total_profit: number;
+    total_commission: number;
+    total_swap: number;
+    avg_profit: number;
+    avg_volume: number;
+}
+interface UpdatePositionRequest {
+    login: number;
+    stop_loss?: number;
+    take_profit?: number;
+}
+interface UpdatePositionResponse {
+    id: number;
+    login: number;
+    symbol: string;
+    stop_loss?: number;
+    take_profit?: number;
+    updated_at: string;
+    message: string;
+}
+interface DeletePositionParams {
+    login: number;
+}
+interface CheckPositionsRequest {
+    ids?: number[];
+    filters?: {
+        logins?: number[];
+        symbols?: string[];
+        states?: string[];
+    };
+}
+interface CheckPositionsResponse {
+    total_checked: number;
+    total_updated: number;
+    positions: Array<{
+        id: number;
+        updated: boolean;
+        message: string;
+        changes?: {
+            profit?: {
+                old: number;
+                new: number;
+            };
+            swap?: {
+                old: number;
+                new: number;
+            };
+        };
+    }>;
+}
+
+/**
+ * Order types
+ */
+interface Order {
+    id: number;
+    login: number;
+    symbol: string;
+    type: 'buy' | 'sell';
+    order_type: 'market' | 'limit' | 'stop' | 'stop_limit';
+    status: 'new' | 'partial' | 'filled' | 'cancelled' | 'rejected' | 'expired';
+    volume: number;
+    filled_volume: number;
+    price: number;
+    stop_price?: number;
+    stop_loss?: number;
+    take_profit?: number;
+    created_at: string;
+    updated_at: string;
+    comment?: string;
+}
+interface OrdersListParams extends PaginationParams {
+    /** Order IDs (comma-separated) */
+    id?: string;
+    /** Account logins (comma-separated) */
+    login?: string;
+    /** Symbols (comma-separated, e.g., "EURUSD,GBPUSD") */
+    symbol?: string;
+    /** Order types: "buy", "sell" (comma-separated) */
+    type?: string;
+    /** Order types: "market", "limit", "stop", "stop_limit" */
+    order_type?: string;
+    /** Order statuses (comma-separated) */
+    status?: string;
+    /** Created from date (RFC3339) */
+    created_from?: string;
+    /** Created to date (RFC3339) */
+    created_to?: string;
+    /** Updated from date (RFC3339) */
+    updated_from?: string;
+    /** Updated to date (RFC3339) */
+    updated_to?: string;
+    /** Minimum price */
+    price_min?: number;
+    /** Maximum price */
+    price_max?: number;
+    /** Minimum volume */
+    volume_min?: number;
+    /** Maximum volume */
+    volume_max?: number;
+    /** Include deleted orders (default: false) */
+    include_deleted?: boolean;
+    /** Sort by field (default: "id") */
+    sort_by?: string;
+    /** Sort order: "asc", "desc" (default: "desc") */
+    sort_order?: 'asc' | 'desc';
+}
+interface OrderStatsParams {
+    /** Account logins (comma-separated) */
+    login?: string;
+    /** Symbols (comma-separated) */
+    symbol?: string;
+    /** Order types: "buy", "sell" (comma-separated) */
+    type?: string;
+    /** Order types: "market", "limit", "stop" */
+    order_type?: string;
+    /** Order statuses (comma-separated) */
+    status?: string;
+    /** Created from date (RFC3339) */
+    created_from?: string;
+    /** Created to date (RFC3339) */
+    created_to?: string;
+    /** Group by: "login", "symbol", "type", "order_type", "status" */
+    group_by?: string;
+}
+interface OrderStatistics {
+    total_orders: number;
+    total_volume: number;
+    total_filled_volume: number;
+    avg_volume: number;
+    avg_price: number;
+    max_volume: number;
+    min_volume: number;
+}
+interface OrderStatisticsGrouped {
+    group_key: string;
+    total_orders: number;
+    total_volume: number;
+    avg_volume: number;
+}
+interface OrderTotalsParams {
+    /** Account logins (comma-separated) */
+    login?: string;
+    /** Symbols (comma-separated) */
+    symbol?: string;
+    /** Order types: "buy", "sell" (comma-separated) */
+    type?: string;
+    /** Order types: "market", "limit", "stop" */
+    order_type?: string;
+    /** Order statuses (comma-separated) */
+    status?: string;
+    /** Group by (required): "login", "symbol", "type", "order_type", "status" */
+    group_by: string;
+}
+interface OrderTotals {
+    group_key: string;
+    count: number;
+    total_volume: number;
+    total_filled_volume: number;
+    avg_volume: number;
+    avg_price: number;
+}
+interface UpdateOrderRequest {
+    login: number;
+    stop_loss?: number;
+    take_profit?: number;
+}
+interface UpdateOrderResponse {
+    id: number;
+    login: number;
+    symbol: string;
+    stop_loss?: number;
+    take_profit?: number;
+    updated_at: string;
+    message: string;
+}
+interface DeleteOrderParams {
+    login: number;
+}
+interface CheckOrdersRequest {
+    ids?: number[];
+    filters?: {
+        logins?: number[];
+        symbols?: string[];
+        statuses?: string[];
+    };
+}
+interface CheckOrdersResponse {
+    total_checked: number;
+    total_updated: number;
+    orders: Array<{
+        id: number;
+        updated: boolean;
+        message: string;
+        changes?: {
+            status?: {
+                old: string;
+                new: string;
+            };
+        };
+    }>;
+}
+
+/**
+ * Trade operation types
+ */
+interface OpenTradeRequest {
+    login: number;
+    symbol: string;
+    action: 'buy' | 'sell';
+    type: 'market' | 'limit' | 'stop' | 'stop_limit';
+    volume: number;
+    price?: number;
+    stop_price?: number;
+    stop_loss?: number;
+    take_profit?: number;
+    force_price?: boolean;
+    force_timestamp?: string;
+    comment?: string;
+    magic?: number;
+}
+interface OpenTradeResponse {
+    order_id: number;
+    position_id: number;
+    status: string;
+    filled_volume: number;
+    fill_price: number;
+    message: string;
+    symbol: string;
+    action: string;
+    volume: number;
+    stop_loss?: number;
+    take_profit?: number;
+    created_at: string;
+    was_forced: boolean;
+}
+interface CloseTradeRequest {
+    login: number;
+    position_id: number;
+    volume?: number;
+    price?: number;
+    force_price?: boolean;
+    force_timestamp?: string;
+    comment?: string;
+}
+interface CloseTradeResponse {
+    position_id: number;
+    closed_volume: number;
+    remaining_volume: number;
+    close_price: number;
+    realized_pnl: number;
+    commission: number;
+    swap: number;
+    net_pnl: number;
+    message: string;
+    symbol: string;
+    was_fully_closed: boolean;
+    closed_at: string;
+    was_forced: boolean;
+}
+interface ModifyTradeRequest {
+    login: number;
+    position_id: number;
+    stop_loss?: number;
+    take_profit?: number;
+    comment?: string;
+}
+interface ModifyTradeResponse {
+    position_id: number;
+    stop_loss?: number;
+    take_profit?: number;
+    message: string;
+    symbol: string;
+    updated_at: string;
+}
+interface CheckMarginRequest {
+    login: number;
+    symbol: string;
+    action: 'buy' | 'sell';
+    volume: number;
+    price?: number;
+}
+interface CheckMarginResponse {
+    margin_required: number;
+    margin_available: number;
+    margin_free: number;
+    can_execute: boolean;
+    leverage: number;
+    symbol: string;
+    volume: number;
+    price: number;
+    account_currency: string;
+    reason?: string;
+}
+interface CalculateProfitRequest {
+    login: number;
+    symbol: string;
+    action: 'buy' | 'sell';
+    volume: number;
+    open_price: number;
+    close_price: number;
+}
+interface CalculateProfitResponse {
+    profit: number;
+    profit_currency: string;
+    profit_pips: number;
+    profit_percent: number;
+    symbol: string;
+    action: string;
+    volume: number;
+    open_price: number;
+    close_price: number;
+    contract_size: number;
+    point_value: number;
+}
+
+/**
+ * Health check types
+ */
+interface HealthCheckResponse {
+    status: 'ok' | 'error';
+    timestamp: string;
+    version?: string;
+}
+
+/**
+ * Required configuration to initialize the Pipsend client
+ */
+interface PipsendConfig {
+    /** Pipsend server URL (required) */
+    server: string;
+    /** User credentials for SDK authentication (optional, for future use) */
+    login?: string;
+    /** User password for SDK authentication (optional, for future use) */
+    password?: string;
+    /** Timezone for operations (optional, default: UTC) */
+    timezone?: string;
+    /** Enable auto-refresh of tokens (default: true) */
+    autoRefresh?: boolean;
+    /** Safety margin for refresh in minutes (default: 5) */
+    refreshMarginMinutes?: number;
+    /** WebSocket configuration (optional) */
+    websocket?: WebSocketConfig;
+}
+/**
+ * Authentication token information
+ */
+interface TokenInfo {
+    token: string;
+    expiresAt: Date;
+    issuedAt: Date;
+}
+/**
+ * Trading order data
+ */
+interface OrderData {
+    symbol: string;
+    volume: number;
+    type?: 'buy' | 'sell';
+    price?: number;
+    stopLoss?: number;
+    takeProfit?: number;
+}
+/**
+ * Server authentication response
+ * TODO: Adjust according to real API response
+ */
+interface AuthResponse {
+    token: string;
+    expiresIn: number;
+}
+/**
+ * Custom SDK errors
+ */
+declare class PipsendError extends Error {
+    code?: string | undefined;
+    statusCode?: number | undefined;
+    constructor(message: string, code?: string | undefined, statusCode?: number | undefined);
+}
+declare class AuthenticationError extends PipsendError {
+    constructor(message: string);
+}
+declare class ConfigurationError extends PipsendError {
+    constructor(message: string);
+}
+declare class WebSocketError extends PipsendError {
+    constructor(message: string);
+}
+
+/**
+ * HTTP client for making requests to the Pipsend API
+ */
+declare class HttpClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    /**
+     * Makes an HTTP request
+     */
+    request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T>(endpoint: string, params?: Record<string, any>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(endpoint: string, body?: any): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(endpoint: string, body?: any): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(endpoint: string): Promise<T>;
+    /**
+     * Builds query string from params object
+     */
+    private buildQueryString;
+}
+
+/**
+ * Accounts API
+ */
+declare class AccountsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all accounts with optional filters and pagination
+     */
+    list(params?: AccountsListParams): Promise<PaginatedResponse<Account> | Account[]>;
+    /**
+     * Get all account logins
+     */
+    getLogins(): Promise<number[]>;
+    /**
+     * Get account statistics with optional filters
+     */
+    getStatistics(params?: AccountStatisticsParams): Promise<AccountStatistics>;
+    /**
+     * Change master password for an account
+     */
+    changeMasterPassword(login: number, request: ChangePasswordRequest): Promise<void>;
+    /**
+     * Change investor password for an account
+     */
+    changeInvestorPassword(login: number, request: ChangePasswordRequest): Promise<void>;
+    /**
+     * Archive an account
+     */
+    archive(login: number): Promise<void>;
+    /**
+     * Unarchive an account
+     */
+    unarchive(login: number): Promise<void>;
+}
+
+/**
+ * Trading Groups API
+ */
+declare class TradingGroupsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all trading groups with optional filters
+     */
+    list(params?: TradingGroupsListParams): Promise<TradingGroup[]>;
+    /**
+     * Get trading group by name
+     */
+    getByName(name: string): Promise<TradingGroup>;
+    /**
+     * Get all trading group names
+     */
+    getNames(): Promise<string[]>;
+    /**
+     * Get trading group statistics
+     */
+    getStatistics(type?: string): Promise<TradingGroupStatistics>;
+}
+
+/**
+ * Market Data API
+ *
+ * Note: All data has a minimum age of 1 hour (no real-time data)
+ */
+declare class MarketDataAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get historical OHLCV candles
+     *
+     * @param params - Candles parameters (symbol and timeframe are required)
+     * @returns Paginated candles or array of candles
+     *
+     * @example
+     * ```ts
+     * // Get last 100 candles
+     * const candles = await client.marketData.getCandles({
+     *   symbol: 'BTCUSD',
+     *   timeframe: '1m',
+     *   limit: 100,
+     *   order: 'desc'
+     * });
+     *
+     * // Get candles with time range
+     * const candles = await client.marketData.getCandles({
+     *   symbol: 'BTCUSD,ETHUSD',
+     *   timeframe: '1h',
+     *   from: '2025-11-01T00:00:00Z',
+     *   to: '2025-11-02T00:00:00Z'
+     * });
+     * ```
+     */
+    getCandles(params: CandlesParams): Promise<PaginatedResponse<Candle> | Candle[]>;
+    /**
+     * Get available symbols with metadata
+     *
+     * @param params - Optional filters for symbols
+     * @returns Paginated symbols or array of symbols
+     *
+     * @example
+     * ```ts
+     * // Get all symbols
+     * const symbols = await client.marketData.getSymbols();
+     *
+     * // Filter by group
+     * const cryptoSymbols = await client.marketData.getSymbols({
+     *   group: 'CRYPTO_MAJOR',
+     *   has_data: true
+     * });
+     * ```
+     */
+    getSymbols(params?: SymbolsParams): Promise<PaginatedResponse<Symbol> | Symbol[]>;
+    /**
+     * Get symbol groups hierarchy
+     *
+     * Note: This endpoint never uses pagination
+     *
+     * @param params - Optional filters for groups
+     * @returns Array of groups
+     *
+     * @example
+     * ```ts
+     * // Get all groups
+     * const groups = await client.marketData.getGroups();
+     *
+     * // Get only root groups
+     * const rootGroups = await client.marketData.getGroups({
+     *   root_only: true
+     * });
+     * ```
+     */
+    getGroups(params?: GroupsParams): Promise<Group[]>;
+}
+
+/**
+ * Positions API
+ */
+declare class PositionsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List positions with optional filters and pagination
+     */
+    list(params?: PositionsListParams): Promise<PaginatedResponse<Position> | Position[]>;
+    /**
+     * Get position statistics with optional filters and grouping
+     */
+    getStats(params?: PositionStatsParams): Promise<PositionStatistics | PositionStatisticsGrouped[]>;
+    /**
+     * Get position totals with dynamic grouping
+     */
+    getTotals(params: PositionTotalsParams): Promise<PositionTotals[]>;
+    /**
+     * Update position (modify SL/TP)
+     */
+    update(id: number, request: UpdatePositionRequest): Promise<UpdatePositionResponse>;
+    /**
+     * Delete (close) position
+     */
+    delete(id: number, params: DeletePositionParams): Promise<void>;
+    /**
+     * Check and recalculate positions
+     */
+    check(request: CheckPositionsRequest): Promise<CheckPositionsResponse>;
+}
+
+/**
+ * Orders API
+ */
+declare class OrdersAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List orders with optional filters and pagination
+     */
+    list(params?: OrdersListParams): Promise<PaginatedResponse<Order> | Order[]>;
+    /**
+     * Get order statistics with optional filters and grouping
+     */
+    getStats(params?: OrderStatsParams): Promise<OrderStatistics | OrderStatisticsGrouped[]>;
+    /**
+     * Get order totals with dynamic grouping
+     */
+    getTotals(params: OrderTotalsParams): Promise<OrderTotals[]>;
+    /**
+     * Update order (modify SL/TP)
+     */
+    update(id: number, request: UpdateOrderRequest): Promise<UpdateOrderResponse>;
+    /**
+     * Delete (cancel) order
+     */
+    delete(id: number, params: DeleteOrderParams): Promise<void>;
+    /**
+     * Check and validate pending orders
+     */
+    check(request: CheckOrdersRequest): Promise<CheckOrdersResponse>;
+}
+
+/**
+ * Trades API
+ */
+declare class TradesAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Open a new trade (market or pending order)
+     */
+    open(request: OpenTradeRequest): Promise<OpenTradeResponse>;
+    /**
+     * Close a trade (full or partial)
+     */
+    close(request: CloseTradeRequest): Promise<CloseTradeResponse>;
+    /**
+     * Modify trade Stop Loss and/or Take Profit
+     */
+    modify(request: ModifyTradeRequest): Promise<ModifyTradeResponse>;
+    /**
+     * Check if there's sufficient margin for a trade
+     */
+    checkMargin(request: CheckMarginRequest): Promise<CheckMarginResponse>;
+    /**
+     * Calculate potential profit for a trade
+     */
+    calculateProfit(request: CalculateProfitRequest): Promise<CalculateProfitResponse>;
+}
+
+/**
+ * Main Pipsend SDK client
+ */
+declare class PipsendClient {
+    private authManager;
+    private wsManager?;
+    private config;
+    private http;
+    readonly accounts: AccountsAPI;
+    readonly tradingGroups: TradingGroupsAPI;
+    readonly marketData: MarketDataAPI;
+    readonly positions: PositionsAPI;
+    readonly orders: OrdersAPI;
+    readonly trades: TradesAPI;
+    constructor(config: PipsendConfig);
+    /**
+     * Validates the initial configuration
+     */
+    private validateConfig;
+    /**
+     * Authentication API
+     * TODO: Implement when authentication is available
+     */
+    auth: {
+        /**
+         * Forces a token refresh
+         */
+        refresh: () => Promise<void>;
+        /**
+         * Checks if the client is authenticated
+         */
+        isAuthenticated: () => boolean;
+        /**
+         * Gets the current token (if it exists)
+         */
+        getToken: () => string | undefined;
+        /**
+         * Logs out by clearing the token
+         */
+        logout: () => void;
+    };
+    /**
+     * WebSocket streaming API
+     * Provides real-time updates for prices, orders, positions, etc.
+     */
+    stream: {
+        /**
+         * Connects to WebSocket server
+         */
+        connect: () => Promise<void>;
+        /**
+         * Disconnects from WebSocket server
+         */
+        disconnect: () => void;
+        /**
+         * Checks if WebSocket is connected
+         */
+        isConnected: () => boolean;
+        /**
+         * Subscribes to symbols or channels
+         * @example
+         * client.stream.subscribe(['EURUSD', 'GBPUSD']);
+         */
+        subscribe: (channels: string[]) => void;
+        /**
+         * Unsubscribes from symbols or channels
+         */
+        unsubscribe: (channels: string[]) => void;
+        /**
+         * Gets list of subscribed channels
+         */
+        getSubscriptions: () => string[];
+        /**
+         * Listens to real-time price updates
+         */
+        onPriceUpdate: (callback: WebSocketCallback<PriceUpdate>) => void;
+        /**
+         * Listens to real-time order updates
+         */
+        onOrderUpdate: (callback: WebSocketCallback<OrderUpdate>) => void;
+        /**
+         * Listens to real-time position updates
+         */
+        onPositionUpdate: (callback: WebSocketCallback<PositionUpdate>) => void;
+        /**
+         * Listens to real-time balance updates
+         */
+        onBalanceUpdate: (callback: WebSocketCallback<BalanceUpdate>) => void;
+        /**
+         * Listens to connection events
+         */
+        onConnected: (callback: WebSocketCallback) => void;
+        /**
+         * Listens to disconnection events
+         */
+        onDisconnected: (callback: WebSocketCallback) => void;
+        /**
+         * Listens to error events
+         */
+        onError: (callback: WebSocketCallback) => void;
+        /**
+         * Removes event listener
+         */
+        off: (event: string, callback?: WebSocketCallback) => void;
+    };
+    /**
+     * Health check
+     */
+    ping(): Promise<HealthCheckResponse>;
+    /**
+     * Client information
+     */
+    getConfig(): Readonly<PipsendConfig>;
+}
+
+/**
+ * Creates a new instance of the Pipsend client
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@pipsend/sdk';
+ *
+ * const client = createClient({
+ *   server: 'https://api.pipsend.com',
+ *   login: 'your-username',
+ *   password: 'your-password',
+ *   timezone: 'America/New_York' // optional
+ * });
+ *
+ * // The SDK handles authentication automatically
+ * await client.orders.send({
+ *   symbol: 'EURUSD',
+ *   volume: 0.1
+ * });
+ * ```
+ */
+declare function createClient(config: PipsendConfig): PipsendClient;
+declare const sdk: {
+    createClient: typeof createClient;
+    PipsendClient: typeof PipsendClient;
+};
+
+export { type Account, type AccountStatistics, type AccountStatisticsParams, type AccountsListParams, type AuthResponse, AuthenticationError, type BalanceUpdate, type CalculateProfitRequest, type CalculateProfitResponse, type Candle, type CandlesParams, type ChangePasswordRequest, type CheckMarginRequest, type CheckMarginResponse, type CloseTradeRequest, type CloseTradeResponse, ConfigurationError, type Group, type GroupsParams, type HealthCheckResponse, type ModifyTradeRequest, type ModifyTradeResponse, type OpenTradeRequest, type OpenTradeResponse, type Order, type OrderData, type OrderStatistics, type OrderUpdate, type OrdersListParams, type PaginatedResponse, type PaginationParams, PipsendClient, type PipsendConfig, PipsendError, type Position, type PositionStatistics, type PositionUpdate, type PositionsListParams, type PriceUpdate, type Symbol, type SymbolsParams, type TokenInfo, type TradingGroup, type TradingGroupStatistics, type TradingGroupsListParams, type UpdateOrderRequest, type UpdatePositionRequest, type WebSocketCallback, type WebSocketConfig, WebSocketError, type WebSocketEventType, type WebSocketMessage, createClient, sdk as default };