@teneo-protocol/sdk 1.0.0

package/dist/teneo-sdk.d.ts

@@ -0,0 +1,703 @@
+/**
+ * Main Teneo Protocol SDK class
+ * Provides a unified interface for external platforms to interact with Teneo agents
+ * Uses manager classes to follow Single Responsibility Principle
+ */
+import { EventEmitter } from "eventemitter3";
+import { z } from "zod";
+import { PartialSDKConfig, SDKConfigBuilder, Agent, Room, RoomInfo, type HealthStatus } from "./types";
+import { SDKEvents } from "./types/events";
+import { FormattedResponse, ResponseFormatOptions } from "./formatters/response-formatter";
+import { SendMessageOptions, AgentCommand } from "./managers";
+export type { SendMessageOptions, AgentCommand };
+export declare const SendMessageOptionsSchema: z.ZodObject<{
+    room: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    waitForResponse: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["raw", "humanized", "both"]>, z.ZodLiteral<"raw">, z.ZodLiteral<"humanized">]>>;
+}, "strip", z.ZodTypeAny, {
+    room?: string | undefined;
+    from?: string | undefined;
+    timeout?: number | undefined;
+    format?: "raw" | "humanized" | "both" | undefined;
+    waitForResponse?: boolean | undefined;
+}, {
+    room?: string | undefined;
+    from?: string | undefined;
+    timeout?: number | undefined;
+    format?: "raw" | "humanized" | "both" | undefined;
+    waitForResponse?: boolean | undefined;
+}>;
+export declare const AgentCommandSchema: z.ZodObject<{
+    agent: z.ZodString;
+    command: z.ZodEffects<z.ZodString, string, string>;
+    room: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    agent: string;
+    command: string;
+    room?: string | undefined;
+}, {
+    agent: string;
+    command: string;
+    room?: string | undefined;
+}>;
+export declare class TeneoSDK extends EventEmitter<SDKEvents> {
+    private config;
+    private readonly logger;
+    private isDestroyed;
+    private readonly wsClient;
+    private readonly webhookHandler;
+    private readonly responseFormatter;
+    private readonly connection;
+    private readonly rooms;
+    private readonly agents;
+    private readonly messages;
+    /**
+     * Creates a new instance of the Teneo Protocol SDK.
+     * Initializes all core components, managers, and validates the provided configuration.
+     * The SDK handles WebSocket connections, authentication, message routing, and webhook delivery.
+     *
+     * @param config - Partial SDK configuration object (only wsUrl is required)
+     * @param config.wsUrl - WebSocket URL to connect to (e.g., 'wss://teneo.example.com')
+     * @param config.privateKey - Optional Ethereum private key for wallet-based authentication
+     * @param config.walletAddress - Optional wallet address (derived from privateKey if not provided)
+     * @param config.autoJoinRooms - Optional array of room IDs to subscribe to automatically on connection
+     * @param config.webhookUrl - Optional webhook URL for receiving event notifications
+     * @param config.reconnect - Enable automatic reconnection (default: true)
+     * @param config.logLevel - Logging level: 'debug', 'info', 'warn', 'error', 'silent' (default: 'info')
+     * @param config.responseFormat - Response format: 'raw', 'humanized', 'both' (default: 'humanized')
+     *
+     * @throws {SDKError} If configuration is invalid (ErrorCode.INVALID_CONFIG)
+     *
+     * @example
+     * ```typescript
+     * // Minimal configuration
+     * const sdk = new TeneoSDK({
+     *   wsUrl: 'wss://teneo.example.com',
+     *   privateKey: '0x...'
+     * });
+     *
+     * // Full configuration
+     * const sdk = new TeneoSDK({
+     *   wsUrl: 'wss://teneo.example.com',
+     *   privateKey: '0x...',
+     *   autoJoinRooms: ['general', 'announcements'],
+     *   webhookUrl: 'https://api.example.com/webhooks',
+     *   logLevel: 'debug',
+     *   responseFormat: 'both',
+     *   reconnect: true,
+     *   maxReconnectAttempts: 10
+     * });
+     *
+     * // Using builder pattern (recommended for complex configs)
+     * const sdk = TeneoSDK.builder()
+     *   .wsUrl('wss://teneo.example.com')
+     *   .privateKey('0x...')
+     *   .withAutoJoinRooms(['general'])
+     *   .build();
+     * ```
+     *
+     * @see {@link SDKConfigBuilder} for fluent configuration API
+     * @see {@link TeneoSDK.builder} for creating a configuration builder
+     */
+    constructor(config: PartialSDKConfig);
+    /**
+     * Establishes a connection to the Teneo network via WebSocket.
+     * Handles authentication automatically and joins any configured auto-join rooms.
+     * Emits 'connection:open', 'auth:success', and 'ready' events on successful connection.
+     *
+     * @returns Promise that resolves when connection and authentication are complete
+     * @throws {SDKError} If the SDK has been destroyed (ErrorCode.SDK_DESTROYED)
+     * @throws {ConnectionError} If WebSocket connection fails
+     * @throws {AuthenticationError} If authentication fails
+     *
+     * @example
+     * ```typescript
+     * const sdk = new TeneoSDK({ wsUrl: 'wss://example.com', privateKey: '0x...' });
+     * await sdk.connect();
+     * console.log('Connected to Teneo network');
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects from the Teneo network and cleans up all active connections.
+     * Clears all timers, pending messages, and stops automatic reconnection attempts.
+     * Emits 'disconnect' event after disconnection is complete.
+     *
+     * @example
+     * ```typescript
+     * sdk.disconnect();
+     * console.log('Disconnected from Teneo network');
+     * ```
+     */
+    disconnect(): void;
+    /**
+     * Sends a message to agents via the coordinator, which intelligently selects
+     * the most appropriate agent based on the message content and agent capabilities.
+     * Can optionally wait for and return the agent's response.
+     *
+     * @param content - The message content to send to agents
+     * @param options - Optional message configuration
+     * @param options.room - Room to send message to (defaults to configured default room)
+     * @param options.from - Sender address (defaults to authenticated wallet address)
+     * @param options.waitForResponse - Whether to wait for agent response (default: false)
+     * @param options.timeout - Response timeout in milliseconds (default: 60000, max: 300000)
+     * @param options.format - Response format: 'raw', 'humanized', or 'both'
+     * @returns Promise that resolves to FormattedResponse if waitForResponse is true, void otherwise
+     * @throws {SDKError} If not connected to the network (ErrorCode.NOT_CONNECTED)
+     * @throws {ValidationError} If content is empty or options are invalid
+     * @throws {TimeoutError} If waitForResponse is true and timeout is exceeded
+     *
+     * @example
+     * ```typescript
+     * // Fire-and-forget message
+     * await sdk.sendMessage('What is the weather today?');
+     *
+     * // Wait for response
+     * const response = await sdk.sendMessage('What is 2+2?', {
+     *   waitForResponse: true,
+     *   timeout: 30000
+     * });
+     * console.log(response.humanized); // Agent's response in human-readable format
+     * ```
+     */
+    sendMessage(content: string, options: SendMessageOptions): Promise<FormattedResponse | void>;
+    /**
+     * Sends a direct command to a specific agent, bypassing the coordinator.
+     * Use this when you know exactly which agent should handle the request.
+     * The command is formatted as "@agentName command" internally.
+     *
+     * @param command - The direct agent command configuration
+     * @param command.agent - The agent ID or name to send the command to
+     * @param command.command - The command text to send to the agent
+     * @param command.room - Room to send command to (defaults to configured default room)
+     * @returns Promise that resolves when the command is sent
+     * @throws {SDKError} If not connected to the network (ErrorCode.NOT_CONNECTED)
+     * @throws {ValidationError} If agent or command are empty, or room is not configured
+     *
+     * @example
+     * ```typescript
+     * // Send command to specific agent
+     * await sdk.sendDirectCommand({
+     *   agent: 'weather-agent',
+     *   command: 'Get forecast for New York',
+     *   room: 'general'
+     * });
+     * ```
+     */
+    sendDirectCommand(command: AgentCommand): Promise<FormattedResponse | void>;
+    /**
+     * Subscribes to a specified room in the Teneo network.
+     * Agents in the room will be able to see and respond to your messages.
+     * Emits 'room:subscribed' event when successfully subscribed.
+     *
+     * @param roomId - The ID of the room to subscribe to
+     * @returns Promise that resolves when the room has been subscribed
+     * @throws {SDKError} If not connected to the network (ErrorCode.NOT_CONNECTED)
+     * @throws {ValidationError} If roomId is empty or invalid
+     *
+     * @example
+     * ```typescript
+     * await sdk.subscribeToRoom('general');
+     * console.log('Subscribed to general room');
+     * ```
+     */
+    subscribeToRoom(roomId: string): Promise<void>;
+    /**
+     * Unsubscribes from a specified room in the Teneo network.
+     * You will no longer receive messages from agents in this room.
+     * Emits 'room:unsubscribed' event when successfully unsubscribed.
+     *
+     * @param roomId - The ID of the room to unsubscribe from
+     * @returns Promise that resolves when the room has been unsubscribed
+     * @throws {SDKError} If not connected to the network (ErrorCode.NOT_CONNECTED)
+     * @throws {ValidationError} If roomId is empty or invalid
+     *
+     * @example
+     * ```typescript
+     * await sdk.unsubscribeFromRoom('general');
+     * console.log('Unsubscribed from general room');
+     * ```
+     */
+    unsubscribeFromRoom(roomId: string): Promise<void>;
+    /**
+     * Lists all rooms available to the user.
+     * Fetches room list from the server including owned and shared rooms.
+     * Emits 'room:list' event when the list is received.
+     *
+     * @returns Promise that resolves to array of room information
+     * @throws {SDKError} If not connected to the network (ErrorCode.NOT_CONNECTED)
+     *
+     * @example
+     * ```typescript
+     * const rooms = await sdk.listRooms();
+     * rooms.forEach(room => {
+     *   console.log(`${room.name} (${room.is_public ? 'public' : 'private'})`);
+     *   console.log(`Owner: ${room.is_owner}`);
+     * });
+     * ```
+     */
+    listRooms(): Promise<RoomInfo[]>;
+    /**
+     * Gets all rooms currently subscribed to.
+     * Returns array of room IDs that you're actively listening to for messages.
+     *
+     * @returns Array of subscribed room IDs
+     *
+     * @example
+     * ```typescript
+     * const rooms = sdk.getSubscribedRooms();
+     * console.log(`Subscribed to ${rooms.length} rooms:`, rooms);
+     * // Example output: Subscribed to 3 rooms: ['general', 'support', 'trading']
+     * ```
+     */
+    getSubscribedRooms(): string[];
+    /**
+     * Gets a list of all available agents in the Teneo network.
+     * The list is automatically updated when new agents join or leave.
+     * Returns a read-only array to prevent external modification.
+     *
+     * @returns Read-only array of all available agents
+     *
+     * @example
+     * ```typescript
+     * const agents = sdk.getAgents();
+     * console.log(`Found ${agents.length} agents:`);
+     * agents.forEach(agent => {
+     *   console.log(`- ${agent.name}: ${agent.description}`);
+     * });
+     * ```
+     */
+    getAgents(): ReadonlyArray<Agent>;
+    /**
+     * Gets a specific agent by its unique ID.
+     * Returns undefined if no agent with the specified ID exists.
+     *
+     * @param agentId - The unique identifier of the agent to retrieve
+     * @returns The agent object if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const agent = sdk.getAgent('weather-agent-001');
+     * if (agent) {
+     *   console.log(`Found agent: ${agent.name}`);
+     *   console.log(`Status: ${agent.status}`);
+     * } else {
+     *   console.log('Agent not found');
+     * }
+     * ```
+     */
+    getAgent(agentId: string): Agent | undefined;
+    /**
+     * Finds all agents that have a specific capability using O(1) indexed lookup (PERF-3).
+     * Much faster than filtering through all agents manually.
+     * Uses capability index for constant-time lookups regardless of agent count.
+     *
+     * @param capability - The capability name to search for (case-insensitive)
+     * @returns Read-only array of agents with the specified capability
+     * @throws {ValidationError} If capability name is invalid
+     *
+     * @example
+     * ```typescript
+     * // Find all weather-capable agents
+     * const weatherAgents = sdk.findAgentsByCapability('weather-forecast');
+     * console.log(`Found ${weatherAgents.length} weather agents`);
+     *
+     * weatherAgents.forEach(agent => {
+     *   console.log(`- ${agent.name}: ${agent.description}`);
+     * });
+     * ```
+     */
+    findAgentsByCapability(capability: string): ReadonlyArray<Agent>;
+    /**
+     * Finds agents by name using O(k) token-based search (PERF-3).
+     * Supports partial matching - searches for tokens within agent names.
+     * Tokenizes both the search query and agent names for flexible matching.
+     *
+     * @param name - Name or partial name to search for (case-insensitive)
+     * @returns Read-only array of agents matching the search
+     * @throws {ValidationError} If name is invalid
+     *
+     * @example
+     * ```typescript
+     * // Find all agents with "weather" in their name
+     * const agents = sdk.findAgentsByName('weather');
+     * // Matches: "Weather Agent", "Weather Forecast Bot", "Advanced Weather API", etc.
+     *
+     * console.log(`Found ${agents.length} agents matching 'weather'`);
+     * ```
+     */
+    findAgentsByName(name: string): ReadonlyArray<Agent>;
+    /**
+     * Finds all agents with a specific status using O(1) indexed lookup (PERF-3).
+     * Uses status index for constant-time lookups regardless of agent count.
+     *
+     * @param status - Agent status: 'online' or 'offline' (case-insensitive)
+     * @returns Read-only array of agents with the specified status
+     * @throws {ValidationError} If status is invalid
+     *
+     * @example
+     * ```typescript
+     * // Get all online agents
+     * const onlineAgents = sdk.findAgentsByStatus('online');
+     * console.log(`${onlineAgents.length} agents are currently online`);
+     *
+     * // Get offline agents
+     * const offlineAgents = sdk.findAgentsByStatus('offline');
+     * ```
+     */
+    findAgentsByStatus(status: string): ReadonlyArray<Agent>;
+    /**
+     * Gets a list of all available rooms in the Teneo network.
+     * Includes rooms you have access to based on your authentication.
+     * Returns a read-only array to prevent external modification.
+     *
+     * @returns Read-only array of all available rooms
+     *
+     * @example
+     * ```typescript
+     * const rooms = sdk.getRooms();
+     * console.log(`Available rooms: ${rooms.length}`);
+     * rooms.forEach(room => {
+     *   console.log(`- ${room.id} (${room.name})`);
+     * });
+     * ```
+     */
+    getRooms(): ReadonlyArray<Room>;
+    /**
+     * Gets a specific room by its unique ID.
+     * Returns undefined if no room with the specified ID exists or if you don't have access.
+     *
+     * @param roomId - The unique identifier of the room to retrieve
+     * @returns The room object if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const room = sdk.getRoom('general');
+     * if (room) {
+     *   console.log(`Found room: ${room.name}`);
+     *   console.log(`Members: ${room.members?.length ?? 0}`);
+     * } else {
+     *   console.log('Room not found or no access');
+     * }
+     * ```
+     */
+    getRoom(roomId: string): Room | undefined;
+    /**
+     * Configures webhook URL and headers for receiving real-time event notifications.
+     * Webhooks allow you to receive events at your server endpoint via HTTP POST requests.
+     * Events include messages, agent responses, errors, and connection state changes.
+     *
+     * @param url - The webhook URL endpoint to receive events (must be HTTPS unless localhost)
+     * @param headers - Optional custom HTTP headers to include with webhook requests
+     * @throws {WebhookError} If URL is invalid or insecure (non-HTTPS and not localhost)
+     *
+     * @example
+     * ```typescript
+     * sdk.configureWebhook('https://api.example.com/webhooks/teneo', {
+     *   'Authorization': 'Bearer your-token',
+     *   'X-Custom-Header': 'value'
+     * });
+     *
+     * // Listen for webhook events
+     * sdk.on('webhook:sent', (payload, url) => {
+     *   console.log('Webhook sent:', payload.event);
+     * });
+     * ```
+     */
+    configureWebhook(url: string, headers?: Record<string, string>): void;
+    /**
+     * Gets the current WebSocket connection state including connection status,
+     * authentication status, reconnection attempts, and timestamps.
+     *
+     * @returns Object containing detailed connection state information
+     * @returns {boolean} returns.connected - Whether WebSocket is currently connected
+     * @returns {boolean} returns.authenticated - Whether authentication is complete
+     * @returns {boolean} returns.reconnecting - Whether currently attempting to reconnect
+     * @returns {number} returns.reconnectAttempts - Number of reconnection attempts made
+     * @returns {Date} returns.lastConnectedAt - Timestamp of last successful connection
+     * @returns {Date} returns.lastDisconnectedAt - Timestamp of last disconnection
+     * @returns {Error} returns.lastError - Last error that occurred
+     *
+     * @example
+     * ```typescript
+     * const state = sdk.getConnectionState();
+     * console.log(`Connected: ${state.connected}`);
+     * console.log(`Authenticated: ${state.authenticated}`);
+     * if (state.reconnecting) {
+     *   console.log(`Reconnection attempts: ${state.reconnectAttempts}`);
+     * }
+     * ```
+     */
+    getConnectionState(): {
+        connected: boolean;
+        authenticated: boolean;
+        reconnecting: boolean;
+        reconnectAttempts: number;
+        lastError?: Error | undefined;
+        lastConnectedAt?: Date | undefined;
+        lastDisconnectedAt?: Date | undefined;
+    };
+    /**
+     * Gets the current authentication state including wallet address, rooms, and permissions.
+     * Updated after successful authentication and includes user profile information.
+     *
+     * @returns Object containing detailed authentication state information
+     * @returns {boolean} returns.authenticated - Whether authentication is complete
+     * @returns {string} returns.walletAddress - Authenticated wallet address
+     * @returns {string} returns.challenge - Authentication challenge string
+     * @returns {string[]} returns.rooms - Array of room IDs the user has access to
+     * @returns {Room[]} returns.roomObjects - Full room objects with details
+     *
+     * @example
+     * ```typescript
+     * const authState = sdk.getAuthState();
+     * if (authState.authenticated) {
+     *   console.log(`Authenticated as: ${authState.walletAddress}`);
+     *   console.log(`Access to ${authState.rooms?.length ?? 0} rooms`);
+     * } else {
+     *   console.log('Not authenticated');
+     * }
+     * ```
+     */
+    getAuthState(): {
+        authenticated: boolean;
+        challenge?: string | undefined;
+        rooms?: string[] | undefined;
+        walletAddress?: string | undefined;
+        clientId?: string | undefined;
+        isWhitelisted?: boolean | undefined;
+        isAdmin?: boolean | undefined;
+        nftVerified?: boolean | undefined;
+        roomObjects?: {
+            name: string;
+            id: string;
+            is_public: boolean;
+            is_active: boolean;
+            created_by: string;
+            created_at: string;
+            updated_at: string;
+            description?: string | undefined;
+        }[] | undefined;
+        privateRoomId?: string | undefined;
+        challengeTimestamp?: number | undefined;
+    };
+    /**
+     * Quick check for whether the WebSocket connection is currently active.
+     * This is a convenience getter that returns only the connection status.
+     * For detailed state information, use getConnectionState().
+     *
+     * @returns True if connected to the Teneo network, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (sdk.isConnected) {
+     *   await sdk.sendMessage('Hello!');
+     * } else {
+     *   console.log('Not connected');
+     *   await sdk.connect();
+     * }
+     * ```
+     */
+    get isConnected(): boolean;
+    /**
+     * Quick check for whether authentication is complete.
+     * This is a convenience getter that returns only the authentication status.
+     * For detailed auth information, use getAuthState().
+     *
+     * @returns True if authenticated with the Teneo network, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (sdk.isAuthenticated) {
+     *   console.log('Ready to send messages');
+     * } else {
+     *   console.log('Waiting for authentication...');
+     * }
+     * ```
+     */
+    get isAuthenticated(): boolean;
+    /**
+     * Configures how agent responses are formatted when received.
+     * Supports raw JSON, humanized text, or both formats simultaneously.
+     * Also controls metadata inclusion and pretty-printing options.
+     *
+     * @param options - Response formatting configuration options
+     * @param options.format - Format type: 'raw' (JSON), 'humanized' (text), or 'both'
+     * @param options.includeMetadata - Whether to include metadata in responses (timestamps, agent info, etc.)
+     * @param options.includeTimestamps - Whether to include timestamps in formatted output
+     * @param options.prettyPrint - Whether to pretty-print JSON output
+     *
+     * @example
+     * ```typescript
+     * // Get both raw JSON and humanized text
+     * sdk.setResponseFormat({
+     *   format: 'both',
+     *   includeMetadata: true
+     * });
+     *
+     * const response = await sdk.sendMessage('Hello', { waitForResponse: true });
+     * console.log(response.humanized); // Human-readable text
+     * console.log(response.raw);       // Original JSON
+     * console.log(response.metadata);  // Timestamp, agent info, etc.
+     * ```
+     */
+    setResponseFormat(options: ResponseFormatOptions): void;
+    /**
+     * Gets the current status of the webhook system including configuration,
+     * queue status, and pending/failed webhook deliveries.
+     *
+     * @returns Object containing webhook status information
+     * @returns {boolean} returns.configured - Whether a webhook URL is configured
+     * @returns {WebhookConfig} returns.config - Current webhook configuration (URL, headers, retries, etc.)
+     * @returns {Object} returns.queue - Webhook delivery queue status
+     * @returns {number} returns.queue.pending - Number of webhooks pending delivery
+     * @returns {boolean} returns.queue.processing - Whether webhooks are currently being processed
+     * @returns {number} returns.queue.failed - Number of failed webhook deliveries in queue
+     *
+     * @example
+     * ```typescript
+     * const status = sdk.getWebhookStatus();
+     * if (status.configured) {
+     *   console.log(`Webhook URL: ${status.config.url}`);
+     *   console.log(`Pending: ${status.queue.pending}`);
+     *   console.log(`Failed: ${status.queue.failed}`);
+     * } else {
+     *   console.log('Webhook not configured');
+     * }
+     * ```
+     */
+    getWebhookStatus(): {
+        configured: boolean;
+        config: {
+            url: string;
+            headers?: Record<string, string> | undefined;
+            retries?: number | undefined;
+            timeout?: number | undefined;
+            events?: ("message" | "task" | "task_response" | "agent_selected" | "error" | "connection_state" | "auth_state")[] | undefined;
+        } | undefined;
+        queue: {
+            pending: number;
+            processing: boolean;
+            failed: number;
+            circuitState: string;
+        };
+    };
+    /**
+     * Retries all failed webhook deliveries in the queue.
+     * Resets attempt counters and immediately attempts to deliver all failed webhooks.
+     * Useful for recovering from temporary network issues or webhook endpoint downtime.
+     *
+     * @example
+     * ```typescript
+     * const status = sdk.getWebhookStatus();
+     * if (status.queue.failed > 0) {
+     *   console.log(`Retrying ${status.queue.failed} failed webhooks...`);
+     *   sdk.retryFailedWebhooks();
+     * }
+     * ```
+     */
+    retryFailedWebhooks(): void;
+    /**
+     * Clears all pending and failed webhooks from the delivery queue.
+     * Use this to discard webhooks that are no longer relevant or to recover from queue issues.
+     * Warning: This will permanently discard all queued webhook events.
+     *
+     * @example
+     * ```typescript
+     * // Clear stale webhooks after reconfiguration
+     * sdk.clearWebhookQueue();
+     * sdk.configureWebhook('https://api.example.com/new-endpoint');
+     * console.log('Webhook queue cleared and reconfigured');
+     * ```
+     */
+    clearWebhookQueue(): void;
+    /**
+     * Gets comprehensive health status of all SDK components.
+     * Useful for monitoring, debugging, and operational dashboards.
+     * Returns status of connection, webhooks, rate limiting, agents, and rooms.
+     *
+     * Overall health status calculation:
+     * - healthy: All components operational
+     * - degraded: Some components have issues but SDK is functional (e.g., webhook failures, circuit open)
+     * - unhealthy: Critical components are not operational (e.g., disconnected, authentication failed)
+     *
+     * @returns Complete health status object with all component states
+     * @returns {string} returns.status - Overall health: 'healthy', 'degraded', or 'unhealthy'
+     * @returns {string} returns.timestamp - ISO timestamp of health check
+     * @returns {Object} returns.connection - WebSocket connection health
+     * @returns {Object} returns.webhook - Webhook delivery health including circuit breaker state
+     * @returns {Object} returns.rateLimit - Rate limiter status (if configured)
+     * @returns {Object} returns.agents - Agent registry health
+     * @returns {Object} returns.rooms - Room management health
+     *
+     * @example
+     * ```typescript
+     * const health = sdk.getHealth();
+     * console.log(`SDK Status: ${health.status}`);
+     * console.log(`Connected: ${health.connection.status}`);
+     * console.log(`Agents: ${health.agents.count}`);
+     * console.log(`Webhook Circuit: ${health.webhook.circuitState}`);
+     *
+     * if (health.status !== 'healthy') {
+     *   console.warn('SDK is degraded or unhealthy');
+     *   if (!health.connection.authenticated) {
+     *     console.log('Authentication issue');
+     *   }
+     *   if (health.webhook.failed > 0) {
+     *     console.log(`${health.webhook.failed} failed webhooks`);
+     *   }
+     * }
+     * ```
+     */
+    getHealth(): HealthStatus;
+    /**
+     * Destroys the SDK instance and cleans up all resources.
+     * Disconnects from the network, clears all managers, removes event listeners,
+     * and marks the SDK as destroyed. After calling destroy(), the SDK instance
+     * cannot be reused - create a new instance instead.
+     * Emits 'destroy' event before completion.
+     *
+     * @example
+     * ```typescript
+     * // Clean up when shutting down
+     * sdk.destroy();
+     * console.log('SDK destroyed and resources cleaned up');
+     *
+     * // Create new instance if needed
+     * const newSdk = new TeneoSDK(config);
+     * ```
+     */
+    destroy(): void;
+    /**
+     * Set up event forwarding from managers
+     */
+    private setupEventForwarding;
+    /**
+     * Create default logger using pino
+     */
+    private createDefaultLogger;
+    /**
+     * Creates a new SDK configuration builder for fluent configuration.
+     * The builder pattern provides a more intuitive way to configure the SDK
+     * with method chaining and validation at each step.
+     *
+     * @returns A new SDKConfigBuilder instance for fluent configuration
+     *
+     * @example
+     * ```typescript
+     * const sdk = TeneoSDK.builder()
+     *   .wsUrl('wss://teneo.example.com')
+     *   .privateKey('0x...')
+     *   .withAutoJoinRooms(['general'])
+     *   .logLevel('debug')
+     *   .webhookUrl('https://api.example.com/webhooks')
+     *   .build();
+     *
+     * await sdk.connect();
+     * ```
+     */
+    static builder(): SDKConfigBuilder;
+}
+//# sourceMappingURL=teneo-sdk.d.ts.map