aparavi-client 1.0.2

package/dist/esm/types/index.js

@@ -0,0 +1,34 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2024 Aparavi Development Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Type definitions for the Aparavi TypeScript SDK.
+ *
+ * Re-exports all type definitions from individual modules for convenient imports.
+ */
+export * from './client';
+export * from './data';
+export * from './events';
+export * from './pipeline';
+export * from './task';
+//# sourceMappingURL=index.js.map

package/dist/esm/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../aparavi-client/src/types/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;GAIG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC"}

package/dist/esm/types/pipeline.js

@@ -0,0 +1,25 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2024 Aparavi Development Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export {};
+//# sourceMappingURL=pipeline.js.map

package/dist/esm/types/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../../aparavi-client/src/types/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/esm/types/task.js

@@ -0,0 +1,112 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2024 Aparavi Development Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Task Management Types: Comprehensive Status Tracking and Event Management System.
+ *
+ * This module defines the complete type system for sophisticated task lifecycle management,
+ * real-time status monitoring, and event-driven communication in distributed computational
+ * pipeline systems. It provides structured data models for tracking complex task execution
+ * states, processing statistics, error management, and pipeline flow visualization.
+ */
+/**
+ * Task lifecycle state enumeration for comprehensive state management.
+ *
+ * This enumeration defines all possible states in the task execution lifecycle,
+ * providing clear state transitions and enabling proper resource management,
+ * error handling, and client notification. Each state represents a distinct
+ * phase with specific characteristics and available operations.
+ *
+ * Lifecycle Phases:
+ * ----------------
+ * NONE: Initial state before any resources are allocated or configuration
+ *       is processed. Tasks in this state can be safely discarded without
+ *       cleanup operations.
+ *
+ * STARTING: Resource allocation and initial setup phase. Ports are allocated,
+ *           temporary files created, and subprocess preparation occurs.
+ *
+ * INITIALIZING: Subprocess has been created and is performing pipeline
+ *               initialization. Service interfaces are being established.
+ *
+ * RUNNING: Task is operational and processing requests. All interfaces
+ *          are available and the pipeline is actively executing.
+ *
+ * STOPPING: Graceful shutdown initiated. Subprocess is being terminated
+ *           and resources are being cleaned up.
+ *
+ * COMPLETED: Task finished successfully. All resources cleaned up and
+ *            final status available for client queries.
+ *
+ * CANCELLED: Task was terminated before completion. Resources cleaned up
+ *            and termination reason available in status.
+ *
+ * State Transitions:
+ * -----------------
+ * Normal execution flow:
+ * NONE → STARTING → INITIALIZING → RUNNING → STOPPING → COMPLETED
+ *
+ * Cancellation flow:
+ * Any state → STOPPING → CANCELLED
+ *
+ * Error handling:
+ * Any state → STOPPING → COMPLETED (with error exit code)
+ *
+ * Resource Management:
+ * -------------------
+ * - NONE/COMPLETED/CANCELLED: No active resources requiring cleanup
+ * - STARTING/INITIALIZING/RUNNING: Active resources requiring cleanup
+ * - STOPPING: Cleanup in progress, resources being deallocated
+ *
+ * Client Operations:
+ * -----------------
+ * - NONE: Configuration and launch operations available
+ * - STARTING/INITIALIZING: Status monitoring available
+ * - RUNNING: Full debugging and data processing operations available
+ * - STOPPING: Limited status monitoring, operations being rejected
+ * - COMPLETED/CANCELLED: Status queries only, task cleanup may be initiated
+ *
+ * Wait Operations:
+ * ---------------
+ * Clients can wait for specific state transitions using wait_for_running()
+ * and similar methods. State transitions trigger event notifications to
+ * all subscribed monitoring clients.
+ */
+export var TASK_STATE;
+(function (TASK_STATE) {
+    /** Initial state - no resources allocated */
+    TASK_STATE[TASK_STATE["NONE"] = 0] = "NONE";
+    /** Resource allocation and subprocess preparation */
+    TASK_STATE[TASK_STATE["STARTING"] = 1] = "STARTING";
+    /** Subprocess initialization and service startup */
+    TASK_STATE[TASK_STATE["INITIALIZING"] = 2] = "INITIALIZING";
+    /** Operational state - processing requests */
+    TASK_STATE[TASK_STATE["RUNNING"] = 3] = "RUNNING";
+    /** Graceful shutdown and resource cleanup in progress */
+    TASK_STATE[TASK_STATE["STOPPING"] = 4] = "STOPPING";
+    /** Successful completion - resources cleaned up */
+    TASK_STATE[TASK_STATE["COMPLETED"] = 5] = "COMPLETED";
+    /** Terminated before completion - resources cleaned up */
+    TASK_STATE[TASK_STATE["CANCELLED"] = 6] = "CANCELLED";
+})(TASK_STATE || (TASK_STATE = {}));
+//# sourceMappingURL=task.js.map

package/dist/esm/types/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../../aparavi-client/src/types/task.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,CAAN,IAAY,UAqBX;AArBD,WAAY,UAAU;IACrB,6CAA6C;IAC7C,2CAAQ,CAAA;IAER,qDAAqD;IACrD,mDAAY,CAAA;IAEZ,oDAAoD;IACpD,2DAAgB,CAAA;IAEhB,8CAA8C;IAC9C,iDAAW,CAAA;IAEX,yDAAyD;IACzD,mDAAY,CAAA;IAEZ,mDAAmD;IACnD,qDAAa,CAAA;IAEb,0DAA0D;IAC1D,qDAAa,CAAA;AACd,CAAC,EArBW,UAAU,KAAV,UAAU,QAqBrB"}

package/dist/types/client.d.ts

@@ -0,0 +1,395 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2024 Aparavi Development Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { DAPClient } from './core/DAPClient';
+import { DAPMessage, AparaviClientConfig } from './types';
+import { TASK_STATUS, UPLOAD_RESULT, PIPELINE_RESULT, PipelineConfig } from './types';
+import { Question } from './schema/Question';
+/**
+ * Streaming data pipe for sending large datasets to Aparavi pipelines.
+ *
+ * DataPipe provides a stream-like interface for uploading data to an Aparavi
+ * pipeline. It handles the low-level protocol details of opening, writing to,
+ * and closing data pipes on the server.
+ *
+ * Usage pattern:
+ * 1. Create pipe using client.pipe()
+ * 2. Call open() to establish the pipe
+ * 3. Call write() multiple times with data chunks
+ * 4. Call close() to finalize and get results
+ *
+ * @example
+ * ```typescript
+ * const pipe = await client.pipe(token, { filename: 'data.json' }, 'application/json');
+ * await pipe.open();
+ * await pipe.write(new TextEncoder().encode('{"data": "value"}'));
+ * const result = await pipe.close();
+ * ```
+ */
+export declare class DataPipe {
+    private _client;
+    private _token;
+    private _objinfo;
+    private _mimeType;
+    private _provider?;
+    private _pipeId?;
+    private _opened;
+    private _closed;
+    /**
+     * Creates a new DataPipe instance.
+     *
+     * @param client - The AparaviClient instance managing this pipe
+     * @param token - Task token for the pipeline receiving the data
+     * @param objinfo - Metadata about the object being sent (e.g., filename, size)
+     * @param mimeType - MIME type of the data being sent (default: 'application/octet-stream')
+     * @param provider - Optional provider name for the data source
+     */
+    constructor(client: AparaviClient, token: string, objinfo?: Record<string, any>, mimeType?: string, provider?: string);
+    /**
+     * Check if the pipe is currently open for writing.
+     *
+     * @returns true if the pipe has been opened and not yet closed
+     */
+    get isOpened(): boolean;
+    /**
+     * Get the unique ID assigned to this pipe by the server.
+     *
+     * This ID is assigned when the pipe is opened and is used for subsequent
+     * write operations. It remains undefined until open() is called successfully.
+     *
+     * @returns The server-assigned pipe ID, or undefined if not yet opened
+     */
+    get pipeId(): number | undefined;
+    /**
+     * Open the pipe for data transmission.
+     *
+     * Establishes a data pipe on the server for streaming data to the pipeline.
+     * Must be called before any write() operations. The server will assign a
+     * unique pipe ID that is used for subsequent operations.
+     *
+     * @returns This DataPipe instance (for method chaining)
+     * @throws Error if the pipe is already opened or if the pipeline is not running
+     */
+    open(): Promise<DataPipe>;
+    /**
+     * Write data to the pipe.
+     *
+     * Sends a chunk of data through the pipe to the server pipeline. Can be called
+     * multiple times to stream large datasets. The pipe must be opened first.
+     *
+     * @param buffer - Data to write, must be a Uint8Array
+     * @throws Error if the pipe is not opened, buffer is invalid, or write fails
+     */
+    write(buffer: Uint8Array): Promise<void>;
+    /**
+     * Close the pipe and get the processing results.
+     *
+     * Finalizes the data stream and signals the server that no more data will be sent.
+     * The server processes any buffered data and returns the final result. After closing,
+     * the pipe cannot be reopened or written to again.
+     *
+     * @returns The processing result from the server, or undefined if already closed
+     * @throws Error if closing the pipe fails
+     */
+    close(): Promise<PIPELINE_RESULT | undefined>;
+}
+/**
+ * Main Aparavi client for connecting to Aparavi servers and services.
+ *
+ * This client provides a comprehensive API for interacting with Aparavi services,
+ * including connection management, pipeline execution, data operations, AI chat,
+ * event handling, and server connectivity testing.
+ *
+ * Key features:
+ * - Single shared WebSocket connection for all operations
+ * - Connection management (connect/disconnect) with optional persistence
+ * - Automatic reconnection when persist mode is enabled
+ * - Pipeline execution (use, terminate, getTaskStatus)
+ * - Data operations (send, sendFiles, pipe)
+ * - AI chat functionality (chat)
+ * - Event handling (setEvents, event callbacks)
+ * - Server connectivity testing (ping)
+ * - Full TypeScript type safety
+ */
+export declare class AparaviClient extends DAPClient {
+    private _uri;
+    private _apikey?;
+    private _env;
+    private _callerOnEvent?;
+    private _callerOnConnected?;
+    private _callerOnDisconnected?;
+    private _dapAttempted;
+    private _dapSend?;
+    private _nextChatId;
+    private _persist;
+    private _reconnectTimeout?;
+    private _reconnectDelay;
+    private _manualDisconnect;
+    /**
+     * Creates a new AparaviClient instance.
+     *
+     * Configuration priority (highest to lowest):
+     * 1. Values passed in config parameter (auth, uri)
+     * 2. Values from env parameter (if provided)
+     * 3. Values from .env file (Node.js only)
+     * 4. Default values
+     *
+     * @param config - Configuration options for the client
+     * @param config.auth - API key for authentication (required)
+     * @param config.uri - Server URI (default: CONST_DEFAULT_SERVICE)
+     * @param config.env - Environment variables dictionary for configuration and substitution
+     * @param config.onEvent - Callback for server events
+     * @param config.onConnected - Callback when connection is established
+     * @param config.onDisconnected - Callback when connection is lost
+     * @param config.persist - Enable automatic reconnection
+     * @param config.reconnectDelay - Delay between reconnection attempts in ms
+     * @param config.module - Optional module name for client identification
+     *
+     * @throws Error if auth is not provided via config, env, or .env file
+     *
+     * @example
+     * ```typescript
+     * // Using explicit auth and URI
+     * const client = new AparaviClient({
+     *   auth: 'your-api-key',
+     *   uri: 'wss://your-server.com',
+     *   persist: true,
+     *   onEvent: (event) => console.log('Event:', event)
+     * });
+     *
+     * // Using custom env dictionary
+     * const client = new AparaviClient({
+     *   env: {
+     *     APARAVI_APIKEY: 'your-api-key',
+     *     APARAVI_URI: 'wss://your-server.com',
+     *     APARAVI_PROJECT_ID: 'my-project'
+     *   }
+     * });
+     * ```
+     */
+    constructor(config?: AparaviClientConfig);
+    /**
+     * Convert HTTP/HTTPS URI to WebSocket URI
+     */
+    private static _convertToWebSocketUri;
+    /**
+     * Clear any pending reconnection timeout
+     */
+    private _clearReconnectTimeout;
+    /**
+     * Schedule a reconnection attempt after the configured delay
+     */
+    private _scheduleReconnect;
+    /**
+     * Check if the client is currently connected to the Aparavi server.
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to the Aparavi server.
+     *
+     * Must be called before executing pipelines or other operations.
+     * In persist mode, enables automatic reconnection on disconnect.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the Aparavi server and stop automatic reconnection.
+     *
+     * Should be called when finished with the client to clean up resources.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a request to the Aparavi server.
+     */
+    request(request: DAPMessage): Promise<DAPMessage>;
+    /**
+     * Test connectivity to the Aparavi server.
+     *
+     * Sends a lightweight ping request to the server to verify it's responding
+     * and reachable. This is useful for connectivity testing, health checks,
+     * and measuring response times.
+     */
+    ping(token?: string): Promise<void>;
+    /**
+     * Substitute environment variables in a string.
+     * Replaces ${APARAVI_*} patterns with values from client's env dictionary.
+     * If variable is not found, leaves it unchanged.
+     */
+    private substituteEnvVars;
+    /**
+     * Recursively process an object/array to substitute environment variables.
+     * Only processes string values, leaving other types unchanged.
+     */
+    private processEnvSubstitution;
+    /**
+     * Start an Aparavi pipeline for processing data.
+     *
+     * This method loads and executes a pipeline configuration. It automatically performs
+     * environment variable substitution on the pipeline config, replacing ${APARAVI_*}
+     * placeholders with values from the .env file.
+     *
+     * @param options - Pipeline execution options
+     * @param options.token - Custom token for the pipeline (auto-generated if not provided)
+     * @param options.filepath - Path to JSON file containing pipeline configuration
+     * @param options.pipeline - Pipeline configuration object (alternative to filepath)
+     * @param options.source - Override pipeline source
+     * @param options.threads - Number of threads for execution (default: 1)
+     * @param options.useExisting - Use existing pipeline instance
+     * @param options.args - Command line arguments to pass to pipeline
+     *
+     * @returns Promise resolving to an object containing the task token and other metadata
+     * @throws Error if neither pipeline nor filepath is provided
+     *
+     * @example
+     * ```typescript
+     * // Using pipeline file
+     * const result = await client.use({ filepath: './pipeline.json' });
+     *
+     * // Using pipeline object
+     * const result = await client.use({
+     *   pipeline: { components: [...], source: 'local', project_id: '123' }
+     * });
+     *
+     * // With environment variable substitution
+     * // Pipeline config: { "endpoint": "${APARAVI_URI}/api" }
+     * // Will be replaced with actual APARAVI_URI value from .env
+     * ```
+     */
+    use(options?: {
+        token?: string;
+        filepath?: string;
+        pipeline?: PipelineConfig;
+        source?: string;
+        threads?: number;
+        useExisting?: boolean;
+        args?: string[];
+    }): Promise<Record<string, any> & {
+        token: string;
+    }>;
+    /**
+     * Terminate a running pipeline.
+     */
+    terminate(token: string): Promise<void>;
+    /**
+     * Get the current status of a running pipeline.
+     */
+    getTaskStatus(token: string): Promise<TASK_STATUS>;
+    /**
+     * Create a data pipe for streaming operations.
+     */
+    pipe(token: string, objinfo?: Record<string, any>, mimeType?: string, provider?: string): Promise<DataPipe>;
+    /**
+     * Send data to a running pipeline.
+     */
+    send(token: string, data: string | Uint8Array, objinfo?: Record<string, any>, mimetype?: string): Promise<PIPELINE_RESULT | undefined>;
+    /**
+     * Upload multiple files to a pipeline with progress tracking and parallel execution.
+     *
+     * This method efficiently uploads files in parallel with configurable concurrency control.
+     * Each file is streamed through a data pipe, and progress events are emitted through the
+     * event system for all subscribers. The order of results matches the input file order.
+     *
+     * Progress events are sent through the event system as 'apaevt_status_upload' events
+     * (matching Python client behavior) rather than through a callback parameter.
+     *
+     * @param files - Array of file objects with optional metadata and MIME types
+     * @param token - Pipeline task token to receive the uploads
+     * @param maxConcurrent - Maximum number of concurrent uploads (default: 5)
+     *
+     * @returns Promise resolving to array of UPLOAD_RESULT objects in the same order as input
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to upload events
+     * client.on('apaevt_status_upload', (event) => {
+     *   console.log(`${event.body.filepath}: ${event.body.bytes_sent}/${event.body.file_size}`);
+     * });
+     *
+     * // Upload files
+     * const results = await client.sendFiles(
+     *   [
+     *     { file: fileObject1 },
+     *     { file: fileObject2, mimetype: 'application/json' },
+     *     { file: fileObject3, objinfo: { custom: 'metadata' } }
+     *   ],
+     *   'task-token',
+     *   10  // Upload max 10 files concurrently
+     * );
+     * ```
+     */
+    sendFiles(files: Array<{
+        file: File;
+        objinfo?: Record<string, any>;
+        mimetype?: string;
+    }>, token: string, maxConcurrent?: number): Promise<UPLOAD_RESULT[]>;
+    /**
+     * Ask a question to Aparavi's AI and get an intelligent response.
+     */
+    chat(options: {
+        token: string;
+        question: Question;
+    }): Promise<PIPELINE_RESULT>;
+    /**
+     * Send events to debugging interface if available (for development).
+     */
+    private _sendVSCodeEvent;
+    /**
+     * Handle incoming events from the Aparavi server.
+     */
+    onEvent(message: DAPMessage): Promise<void>;
+    /**
+     * Handle connected events from the Aparavi server.
+     */
+    onConnected(connectionInfo: string): Promise<void>;
+    /**
+     * Handle disconnected events from the Aparavi server.
+     */
+    onDisconnected(reason: string, hasError: boolean): Promise<void>;
+    /**
+     * Subscribe to specific types of events from the server.
+     */
+    setEvents(token: string, eventTypes: string[]): Promise<void>;
+    /**
+     * Async disposal support for 'await using' pattern.
+     * Equivalent to Python's __aexit__
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Static factory method for automatic connection management.
+     * Equivalent to Python's async with pattern
+     */
+    static withConnection<T>(config: AparaviClientConfig, callback: (client: AparaviClient) => Promise<T>): Promise<T>;
+    /**
+     * Get connection information (TypeScript-specific convenience)
+     */
+    getConnectionInfo(): {
+        connected: boolean;
+        transport: string;
+        uri: string;
+    };
+    /**
+     * Get API key (for debugging/validation)
+     */
+    getApiKey(): string | undefined;
+}
+export { AparaviClient as default };
+//# sourceMappingURL=client.d.ts.map

package/dist/types/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../aparavi-client/src/client.ts"],"names":[],"mappings":"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"}

package/dist/types/constants.d.ts

@@ -0,0 +1,34 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2024 Aparavi Development Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * Default Aparavi service endpoint URL.
+ * Used when no custom URI is provided in the client configuration.
+ */
+export declare const CONST_DEFAULT_SERVICE = "https://eaas.aparavi.com";
+/**
+ * WebSocket connection timeout in seconds.
+ * If no communication occurs within this period, the connection may be considered stale.
+ */
+export declare const CONST_SOCKET_TIMEOUT = 180;
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../aparavi-client/src/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC"}