rocketride 1.0.0

package/dist/types/client.d.ts

@@ -0,0 +1,798 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2026 RocketRide, Inc.
+ *
+ * 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, RocketRideClientConfig } 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 RocketRide pipelines.
+ *
+ * DataPipe provides a stream-like interface for uploading data to an RocketRide
+ * 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 RocketRideClient 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: RocketRideClient, token: string, objinfo?: Record<string, unknown>, 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 RocketRide client for connecting to RocketRide servers and services.
+ *
+ * This client provides a comprehensive API for interacting with RocketRide 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 RocketRideClient extends DAPClient {
+    private _uri;
+    private _apikey?;
+    private _env;
+    private _callerOnEvent?;
+    private _callerOnConnected?;
+    private _callerOnDisconnected?;
+    private _callerOnConnectError?;
+    private _dapAttempted;
+    private _dapSend?;
+    private _nextChatId;
+    private _persist;
+    private _reconnectTimeout?;
+    private _manualDisconnect;
+    private _maxRetryTime?;
+    private _retryStartTime?;
+    private _currentReconnectDelay;
+    /** True after onConnected has been invoked; used to only invoke onDisconnected when we had a connection. */
+    private _didNotifyConnected;
+    /**
+     * Creates a new RocketRideClient 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.requestTimeout - Default timeout in ms for individual requests
+     * @param config.maxRetryTime - Max total time in ms to keep retrying connections
+     * @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 RocketRideClient({
+     *   auth: 'your-api-key',
+     *   uri: 'wss://your-server.com',
+     *   persist: true,
+     *   onEvent: (event) => console.log('Event:', event)
+     * });
+     *
+     * // Using custom env dictionary
+     * const client = new RocketRideClient({
+     *   env: {
+     *     ROCKETRIDE_APIKEY: 'your-api-key',
+     *     ROCKETRIDE_URI: 'wss://your-server.com',
+     *     ROCKETRIDE_PROJECT_ID: 'my-project'
+     *   }
+     * });
+     * ```
+     */
+    constructor(config?: RocketRideClientConfig);
+    /**
+     * Update the server URI (internal). Accepts HTTP/HTTPS/WS/WSS; converts to WebSocket and appends /task/service.
+     */
+    private _setUri;
+    /**
+     * Update the authentication credential (internal).
+     */
+    private _setAuth;
+    /**
+     * Clear any pending reconnection timeout.
+     */
+    private _clearReconnectTimeout;
+    /**
+     * Single place for physical connection. Creates transport if needed, then
+     * calls DAPClient.connect (transport connect + auth handshake + onConnected).
+     */
+    private _internalConnect;
+    /**
+     * Single place for physical disconnect. Closes the transport directly,
+     * which triggers onDisconnected via the transport callback.
+     */
+    private _internalDisconnect;
+    /**
+     * Try to connect; on auth error notify and stop; on other error notify and
+     * reschedule with exponential backoff. Used by persist-mode connect() and
+     * by the reconnect timer.
+     */
+    private _attemptConnection;
+    /**
+     * Schedule a reconnection attempt with exponential backoff.
+     */
+    private _scheduleReconnect;
+    /**
+     * Check if the client is currently connected to the RocketRide server.
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to the RocketRide server.
+     *
+     * Must be called before executing pipelines or other operations.
+     * In persist mode, enables automatic reconnection on disconnect and on initial failure
+     * (calls onConnectError on each failed attempt and keeps retrying).
+     * @param timeout - Optional overall timeout in ms for the connect + auth handshake.
+     */
+    connect(timeout?: number): Promise<void>;
+    /**
+     * Disconnect from the RocketRide server and stop automatic reconnection.
+     *
+     * Should be called when finished with the client to clean up resources.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Update server URI and/or auth at runtime. If currently connected,
+     * disconnects and reconnects with the new params. In persist mode,
+     * reconnection is scheduled only if we were connected.
+     */
+    setConnectionParams(options: {
+        uri?: string;
+        auth?: string;
+    }): Promise<void>;
+    /**
+     * Test connectivity to the RocketRide 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 ${ROCKETRIDE_*} 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;
+    /**
+     * Validate a pipeline configuration.
+     *
+     * Sends the pipeline to the server for structural validation, checking
+     * component compatibility, connection integrity, and the resolved
+     * execution chain.
+     *
+     * Source resolution follows the same logic as {@link use}:
+     * 1. Explicit `source` option (if provided)
+     * 2. `source` field inside the pipeline config
+     * 3. Implied source: the single component whose config.mode is 'Source'
+     *
+     * @param options.pipeline - Pipeline configuration to validate
+     * @param options.source - Optional override for the source component ID
+     * @returns Promise resolving to validation result with errors, warnings,
+     *          resolved component, and execution chain
+     * @throws Error if the server returns a validation error
+     *
+     * @example
+     * ```typescript
+     * const result = await client.validate({
+     *   pipeline: { components: [...], project_id: '123' },
+     *   source: 'webhook_1'
+     * });
+     * if (result.errors?.length) {
+     *   console.log('Validation errors:', result.errors);
+     * }
+     * ```
+     */
+    validate(options: {
+        pipeline: PipelineConfig | Record<string, unknown>;
+        source?: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Start an RocketRide pipeline for processing data.
+     *
+     * This method loads and executes a pipeline configuration. It automatically performs
+     * environment variable substitution on the pipeline config, replacing ${ROCKETRIDE_*}
+     * 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
+     * @param options.ttl - Time-to-live in seconds for idle pipelines (optional, server default if not provided; use 0 for no timeout)
+     *
+     * @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: { name: 'My Pipeline', components: [...], source: 'local', project_id: '123' }
+     * });
+     *
+     * // With environment variable substitution
+     * // Pipeline config: { "endpoint": "${ROCKETRIDE_URI}/api" }
+     * // Will be replaced with actual ROCKETRIDE_URI value from .env
+     * ```
+     */
+    use(options?: {
+        token?: string;
+        filepath?: string;
+        pipeline?: PipelineConfig;
+        source?: string;
+        threads?: number;
+        useExisting?: boolean;
+        args?: string[];
+        ttl?: number;
+    }): Promise<Record<string, unknown> & {
+        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>;
+    /** Return objinfo with size set; never 0 (parse filter skips "empty"). */
+    private _objinfoWithSize;
+    /**
+     * Create a data pipe for streaming operations.
+     */
+    pipe(token: string, objinfo?: Record<string, unknown>, mimeType?: string, provider?: string): Promise<DataPipe>;
+    /**
+     * Send data to a running pipeline.
+     */
+    send(token: string, data: string | Uint8Array, objinfo?: Record<string, unknown>, 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, unknown>;
+        mimetype?: string;
+    }>, token: string): Promise<UPLOAD_RESULT[]>;
+    /**
+     * Ask a question to RocketRide'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 RocketRide server.
+     */
+    onEvent(message: DAPMessage): Promise<void>;
+    /**
+     * Handle connection attempt failure.
+     * Calls the user callback and chains to parent.
+     */
+    onConnectError(error: Error): Promise<void>;
+    /**
+     * Handle connected events from the RocketRide server.
+     */
+    onConnected(connectionInfo: string): Promise<void>;
+    /**
+     * Handle disconnected events from the RocketRide server.
+     * Only invokes the user's onDisconnected if onConnected had previously been called
+     * (so "disconnect without ever connecting" does not fire the user callback).
+     */
+    onDisconnected(reason: string, hasError: boolean): Promise<void>;
+    /**
+     * Subscribe to specific types of events from the server.
+     */
+    setEvents(token: string, eventTypes: string[]): Promise<void>;
+    /**
+     * Save or update a project pipeline.
+     *
+     * Stores a project pipeline configuration on the server. If the project
+     * already exists, it will be updated. Use expectedVersion to ensure
+     * you're updating the version you expect (prevents conflicts).
+     *
+     * @param options - Save project options
+     * @param options.projectId - Unique identifier for the project
+     * @param options.pipeline - Pipeline configuration object
+     * @param options.expectedVersion - Expected current version for atomic updates (optional)
+     * @returns Promise resolving to save result with success status, projectId, and new version
+     * @throws Error if save fails due to version mismatch, storage error, or invalid input
+     *
+     * @example
+     * ```typescript
+     * // Save a new project
+     * const result = await client.saveProject({
+     *   projectId: 'proj-123',
+     *   pipeline: {
+     *     name: 'Data Processor',
+     *     source: 'source_1',
+     *     components: [...]
+     *   }
+     * });
+     * console.log(`Saved version: ${result.version}`);
+     *
+     * // Update existing project with version check
+     * const existing = await client.getProject({ projectId: 'proj-123' });
+     * existing.name = 'Updated Name';
+     * const updated = await client.saveProject({
+     *   projectId: 'proj-123',
+     *   pipeline: existing,
+     *   expectedVersion: existing.version
+     * });
+     * ```
+     */
+    saveProject(options: {
+        projectId: string;
+        pipeline: Record<string, any>;
+        expectedVersion?: string;
+    }): Promise<{
+        success: boolean;
+        project_id: string;
+        version: string;
+    }>;
+    /**
+     * Retrieve a project by its ID.
+     *
+     * Fetches the complete pipeline configuration and current version for
+     * the specified project. Use this before updating to get the current
+     * version for atomic updates.
+     *
+     * @param options - Get project options
+     * @param options.projectId - Unique identifier of the project to retrieve
+     * @returns Promise resolving to project data with success status, pipeline, and version
+     * @throws Error if project doesn't exist or retrieval fails
+     *
+     * @example
+     * ```typescript
+     * // Get a project
+     * try {
+     *   const project = await client.getProject({ projectId: 'proj-123' });
+     *   console.log(`Project: ${project.name}`);
+     *   console.log(`Version: ${project.version}`);
+     * } catch (error) {
+     *   if (error.message.includes('NOT_FOUND')) {
+     *     console.log("Project doesn't exist");
+     *   }
+     * }
+     *
+     * // Before updating - get current version
+     * const project = await client.getProject({ projectId: 'proj-123' });
+     * project.name = 'Updated';
+     * await client.saveProject({
+     *   projectId: 'proj-123',
+     *   pipeline: project,
+     *   expectedVersion: project.version
+     * });
+     * ```
+     */
+    getProject(options: {
+        projectId: string;
+    }): Promise<{
+        success: boolean;
+        pipeline: Record<string, any>;
+        version: string;
+    }>;
+    /**
+     * Delete a project by its ID.
+     *
+     * Permanently removes a project from storage. Optionally verify the
+     * version before deletion to ensure you're deleting the version you
+     * expect (prevents accidental deletion of modified projects).
+     *
+     * @param options - Delete project options
+     * @param options.projectId - Unique identifier of the project to delete
+     * @param options.expectedVersion - Expected current version for atomic deletion (required)
+     * @returns Promise resolving to deletion result with success status and message
+     * @throws Error if project doesn't exist, version mismatch, or deletion fails
+     *
+     * @example
+     * ```typescript
+     * // Safe deletion with version check
+     * const project = await client.getProject({ projectId: 'proj-123' });
+     * try {
+     *   const result = await client.deleteProject({
+     *     projectId: 'proj-123',
+     *     expectedVersion: project.version
+     *   });
+     *   console.log('Project deleted successfully');
+     * } catch (error) {
+     *   if (error.message.includes('CONFLICT')) {
+     *     console.log('Project was modified, deletion cancelled');
+     *   }
+     * }
+     * ```
+     */
+    deleteProject(options: {
+        projectId: string;
+        expectedVersion?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * List all projects for the current user.
+     *
+     * Retrieves a summary of all projects stored for the authenticated user.
+     * Each project summary includes the ID, name, list of data sources, and total component count.
+     *
+     * @returns Promise resolving to list result with success status, projects array, and count
+     * @throws Error if retrieval fails
+     *
+     * @example
+     * ```typescript
+     * // List all projects
+     * const result = await client.getAllProjects();
+     * console.log(`Found ${result.count} projects:`);
+     * for (const project of result.projects) {
+     *   console.log(`- ${project.id}: ${project.name} (${project.totalComponents} components)`);
+     *   for (const source of project.sources) {
+     *     console.log(`  * ${source.name} (${source.provider})`);
+     *   }
+     * }
+     *
+     * // Find specific project
+     * const result = await client.getAllProjects();
+     * const myProject = result.projects.find(p => p.id === 'proj-123');
+     * ```
+     */
+    getAllProjects(): Promise<{
+        success: boolean;
+        projects: Array<{
+            id: string;
+            name: string;
+            sources: Array<{
+                id: string;
+                provider: string;
+                name: string;
+            }>;
+            totalComponents: number;
+        }>;
+        count: number;
+    }>;
+    /**
+     * Save or update a template pipeline.
+     *
+     * Stores a template pipeline configuration on the server. Templates are system-wide
+     * and accessible to all users. If the template already exists, it will be updated.
+     * Use expectedVersion to ensure you're updating the version you expect.
+     *
+     * @param options - Save template options
+     * @param options.templateId - Unique identifier for the template
+     * @param options.pipeline - Pipeline configuration object
+     * @param options.expectedVersion - Expected current version for atomic updates (optional)
+     * @returns Promise resolving to save result with success status, templateId, and new version
+     * @throws Error if save fails due to version mismatch, storage error, or invalid input
+     */
+    saveTemplate(options: {
+        templateId: string;
+        pipeline: Record<string, any>;
+        expectedVersion?: string;
+    }): Promise<{
+        success: boolean;
+        template_id: string;
+        version: string;
+    }>;
+    /**
+     * Retrieve a template by its ID.
+     */
+    getTemplate(options: {
+        templateId: string;
+    }): Promise<{
+        success: boolean;
+        pipeline: Record<string, any>;
+        version: string;
+    }>;
+    /**
+     * Delete a template by its ID.
+     */
+    deleteTemplate(options: {
+        templateId: string;
+        expectedVersion?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * List all templates.
+     */
+    getAllTemplates(): Promise<{
+        success: boolean;
+        templates: Array<{
+            id: string;
+            name: string;
+            sources: Array<{
+                id: string;
+                provider: string;
+                name: string;
+            }>;
+            totalComponents: number;
+        }>;
+        count: number;
+    }>;
+    /**
+     * Save a log file for a source run.
+     */
+    saveLog(options: {
+        projectId: string;
+        source: string;
+        contents: Record<string, any>;
+    }): Promise<{
+        success: boolean;
+        filename: string;
+    }>;
+    /**
+     * Get a log file by source name and start time.
+     */
+    getLog(options: {
+        projectId: string;
+        source: string;
+        startTime: number;
+    }): Promise<{
+        success: boolean;
+        contents: Record<string, any>;
+    }>;
+    /**
+     * List log files for a project.
+     */
+    listLogs(options: {
+        projectId: string;
+        source?: string;
+        page?: number;
+    }): Promise<{
+        success: boolean;
+        logs: string[];
+        count: number;
+        total_count: number;
+        page: number;
+        total_pages: number;
+    }>;
+    /**
+     * Send an arbitrary DAP command with command name, arguments, and optional token.
+     *
+     * This is a convenience method for callers that don't want to construct
+     * full DAPMessage objects. It builds the request internally and delegates
+     * to the underlying request() method.
+     *
+     * @param command - The DAP command name (e.g., 'rrext_services', 'rrext_monitor')
+     * @param args - Optional arguments for the command
+     * @param token - Optional task/session token
+     * @param timeout - Optional per-request timeout in ms
+     * @returns The response DAPMessage from the server
+     */
+    dapRequest(command: string, args?: Record<string, unknown>, token?: string, timeout?: number): Promise<DAPMessage>;
+    /**
+     * 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: RocketRideClientConfig, callback: (client: RocketRideClient) => Promise<T>): Promise<T>;
+    /**
+     * Retrieve all available service definitions from the server.
+     *
+     * Returns a dictionary containing all service definitions available on
+     * the connected RocketRide server. Each service definition includes schemas,
+     * UI schemas, and configuration metadata.
+     *
+     * @returns Promise resolving to object mapping service names to their definitions
+     * @throws Error if the request fails or server returns an error
+     *
+     * @example
+     * ```typescript
+     * // Get all available services
+     * const services = await client.getServices();
+     *
+     * // List available service names
+     * for (const name of Object.keys(services)) {
+     *   console.log(`Available service: ${name}`);
+     * }
+     *
+     * // Access a specific service's schema
+     * if (services['ocr']) {
+     *   console.log('OCR schema:', services['ocr'].schema);
+     * }
+     * ```
+     */
+    getServices(): Promise<Record<string, unknown>>;
+    /**
+     * Retrieve a specific service definition from the server.
+     *
+     * Returns the definition for a specific service (connector) by name.
+     * The definition includes schemas, UI schemas, and configuration metadata.
+     *
+     * @param service - Name of the service to retrieve (e.g., 'ocr', 'embed', 'chat')
+     * @returns Promise resolving to service definition or undefined if not found
+     * @throws Error if the request fails or server returns an error
+     *
+     * @example
+     * ```typescript
+     * // Get OCR service definition
+     * const ocr = await client.getService('ocr');
+     * if (ocr) {
+     *   console.log('OCR schema:', ocr.schema);
+     *   console.log('OCR UI schema:', ocr.uiSchema);
+     * } else {
+     *   console.log('OCR service not available');
+     * }
+     * ```
+     */
+    getService(service: string): Promise<Record<string, unknown> | undefined>;
+    /**
+     * Get connection information (TypeScript-specific convenience)
+     */
+    getConnectionInfo(): {
+        connected: boolean;
+        transport: string;
+        uri: string;
+    };
+    /**
+     * Get API key (for debugging/validation)
+     */
+    getApiKey(): string | undefined;
+}
+export { RocketRideClient as default };
+//# sourceMappingURL=client.d.ts.map