@jack-kernel/sdk 1.0.0

package/dist/types/cache.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Simple in-memory cache with TTL support
+ */
+export declare class Cache {
+    private store;
+    private readonly defaultTTL;
+    constructor(defaultTTL?: number);
+    /**
+     * Get value from cache if not expired
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Set value in cache with TTL
+     */
+    set<T>(key: string, value: T, ttl?: number): void;
+    /**
+     * Clear cache entries matching pattern
+     */
+    clear(pattern?: string): void;
+    /**
+     * Get cache size
+     */
+    size(): number;
+}
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,UAAU,GAAE,MAAc;IAItC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAgB7B;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAKjD;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAc7B;;OAEG;IACH,IAAI,IAAI,MAAM;CAGf"}

package/dist/types/client.d.ts

@@ -0,0 +1,46 @@
+import type { ClientConfig, RequestOptions } from './types.js';
+/**
+ * Core HTTP client for JACK API with retry logic, timeout handling, and caching
+ */
+export declare class JackClient {
+    private readonly config;
+    private readonly cache;
+    constructor(config: ClientConfig);
+    /**
+     * Validate client configuration
+     */
+    private validateConfig;
+    /**
+     * Perform GET request with caching support
+     */
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Perform POST request (never cached)
+     */
+    post<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * Clear cache entries matching pattern
+     */
+    clearCache(pattern?: string): void;
+    /**
+     * Generate cache key from URL and options
+     */
+    private getCacheKey;
+    /**
+     * Execute HTTP request with timeout
+     */
+    private executeRequest;
+    /**
+     * Execute function with retry logic and exponential backoff
+     */
+    private executeWithRetry;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryable;
+    /**
+     * Sleep for specified milliseconds
+     */
+    private sleep;
+}
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG/D;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;gBAElB,MAAM,EAAE,YAAY;IAiBhC;;OAEG;IACH,OAAO,CAAC,cAAc;IAgCtB;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAwBhE;;OAEG;IACG,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC;IAMhF;;OAEG;IACH,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAIlC;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;YACW,cAAc;IA0E5B;;OAEG;YACW,gBAAgB;IA8C9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}

package/dist/types/costs.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Cost tracking module for JACK SDK
+ *
+ * Provides methods to query execution costs and budgets.
+ * Validates Requirements 4.1, 4.2
+ */
+import type { JackClient } from './client.js';
+import type { CostsResponse, IssueCost } from './types.js';
+/**
+ * CostTracker class for querying execution costs and budgets
+ *
+ * @example
+ * ```typescript
+ * const tracker = new CostTracker(client);
+ * const costs = await tracker.getCosts();
+ * const issueCost = await tracker.getIssueCost('ISSUE-123');
+ * const overBudget = await tracker.getOverBudgetIssues();
+ * ```
+ */
+export declare class CostTracker {
+    private readonly client;
+    constructor(client: JackClient);
+    /**
+     * Get all issue costs from the API
+     *
+     * Makes a GET request to /api/costs and returns the complete response
+     * with cost data for all issues.
+     *
+     * @returns Promise resolving to CostsResponse with all issue costs
+     * @throws {APIError} If the API request fails
+     * @throws {NetworkError} If network connection fails
+     *
+     * @example
+     * ```typescript
+     * const costs = await tracker.getCosts();
+     * console.log(`Found ${costs.issueCosts.length} issues`);
+     * ```
+     *
+     * Validates Requirement 4.1
+     */
+    getCosts(): Promise<CostsResponse>;
+    /**
+     * Get costs for a specific issue
+     *
+     * Fetches all costs and filters by the specified issue ID.
+     * Returns null if the issue is not found.
+     *
+     * @param issueId - The issue identifier to filter by
+     * @returns Promise resolving to IssueCost or null if not found
+     * @throws {APIError} If the API request fails
+     * @throws {NetworkError} If network connection fails
+     *
+     * @example
+     * ```typescript
+     * const issueCost = await tracker.getIssueCost('ISSUE-123');
+     * if (issueCost) {
+     *   console.log(`Total cost: ${issueCost.totalCost}`);
+     *   console.log(`Budget: ${issueCost.budget}`);
+     *   console.log(`Over budget: ${issueCost.overBudget}`);
+     * }
+     * ```
+     *
+     * Validates Requirement 4.2
+     */
+    getIssueCost(issueId: string): Promise<IssueCost | null>;
+    /**
+     * Get all issues that are over budget
+     *
+     * Fetches all costs and filters to only those with overBudget flag set to true.
+     * Returns an empty array if no issues are over budget.
+     *
+     * @returns Promise resolving to array of IssueCost objects that are over budget
+     * @throws {APIError} If the API request fails
+     * @throws {NetworkError} If network connection fails
+     *
+     * @example
+     * ```typescript
+     * const overBudget = await tracker.getOverBudgetIssues();
+     * if (overBudget.length > 0) {
+     *   console.log(`Warning: ${overBudget.length} issues are over budget`);
+     *   overBudget.forEach(issue => {
+     *     console.log(`${issue.issueId}: ${issue.totalCost} / ${issue.budget}`);
+     *   });
+     * }
+     * ```
+     *
+     * Validates Requirement 4.2
+     */
+    getOverBudgetIssues(): Promise<IssueCost[]>;
+}
+//# sourceMappingURL=costs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"costs.d.ts","sourceRoot":"","sources":["../../src/costs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,UAAU;IAE/C;;;;;;;;;;;;;;;;;OAiBG;IACG,QAAQ,IAAI,OAAO,CAAC,aAAa,CAAC;IAIxC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAQ9D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,mBAAmB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;CAIlD"}

package/dist/types/errors.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Error hierarchy for the JACK SDK
+ *
+ * This module defines custom error classes for different failure scenarios.
+ * All errors extend the base JackError class and include context for debugging.
+ * Requirements: 5.2, 5.3
+ */
+/**
+ * Base error class for all JACK SDK errors
+ *
+ * Extends the native Error class and adds optional context for debugging.
+ * All SDK-specific errors inherit from this class.
+ *
+ * @example
+ * ```typescript
+ * throw new JackError('Something went wrong', { requestId: '123', timestamp: Date.now() });
+ * ```
+ *
+ * Requirement 5.2
+ */
+export declare class JackError extends Error {
+    /**
+     * Additional context information for debugging
+     * Can include request details, timestamps, or any relevant metadata
+     */
+    readonly context?: Record<string, unknown>;
+    /**
+     * Creates a new JackError
+     *
+     * @param message - Human-readable error message
+     * @param context - Optional context object with debugging information
+     */
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when network-level failures occur
+ *
+ * This includes connection failures, DNS resolution errors, timeouts at the
+ * network layer, and other transport-level issues. The original error is
+ * preserved for detailed debugging.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetch('https://api.jack.example');
+ * } catch (err) {
+ *   throw new NetworkError('Failed to connect to API', err as Error);
+ * }
+ * ```
+ *
+ * Requirement 5.3
+ */
+export declare class NetworkError extends JackError {
+    /**
+     * The original error that caused the network failure
+     * Preserved for detailed debugging and error analysis
+     */
+    readonly originalError: Error;
+    /**
+     * Creates a new NetworkError
+     *
+     * @param message - Human-readable error message
+     * @param originalError - The underlying error that caused the network failure
+     * @param context - Optional additional context
+     */
+    constructor(message: string, originalError: Error, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when the API returns an error response
+ *
+ * This includes 4xx client errors (bad request, not found, unauthorized) and
+ * 5xx server errors (internal server error, service unavailable). The HTTP
+ * status code and response body are included for debugging.
+ *
+ * @example
+ * ```typescript
+ * if (response.status >= 400) {
+ *   throw new APIError(
+ *     'Intent not found',
+ *     404,
+ *     { error: 'Intent with ID JK-ABC123456 does not exist' }
+ *   );
+ * }
+ * ```
+ *
+ * Requirement 5.3
+ */
+export declare class APIError extends JackError {
+    /**
+     * HTTP status code from the API response
+     * Used to distinguish between client errors (4xx) and server errors (5xx)
+     */
+    readonly statusCode: number;
+    /**
+     * The parsed response body from the API
+     * May contain error details, validation messages, or other diagnostic information
+     */
+    readonly response?: unknown;
+    /**
+     * Creates a new APIError
+     *
+     * @param message - Human-readable error message
+     * @param statusCode - HTTP status code from the response
+     * @param response - Optional parsed response body
+     * @param context - Optional additional context
+     */
+    constructor(message: string, statusCode: number, response?: unknown, context?: Record<string, unknown>);
+    /**
+     * Check if this is a client error (4xx status code)
+     * @returns true if status code is in the 400-499 range
+     */
+    isClientError(): boolean;
+    /**
+     * Check if this is a server error (5xx status code)
+     * @returns true if status code is in the 500-599 range
+     */
+    isServerError(): boolean;
+    /**
+     * Check if this error is retryable
+     * Server errors (5xx) are typically retryable, client errors (4xx) are not
+     * @returns true if the error should be retried
+     */
+    isRetryable(): boolean;
+}
+/**
+ * Error thrown when client-side validation fails
+ *
+ * This error is thrown before making any network requests when input parameters
+ * fail validation checks. It includes an array of specific validation errors
+ * to help developers identify and fix issues.
+ *
+ * @example
+ * ```typescript
+ * const errors = [];
+ * if (params.amountIn <= 0) errors.push('amountIn must be positive');
+ * if (params.deadline < Date.now()) errors.push('deadline must be in the future');
+ * if (errors.length > 0) {
+ *   throw new ValidationError('Invalid intent parameters', errors);
+ * }
+ * ```
+ *
+ * Requirement 5.3
+ */
+export declare class ValidationError extends JackError {
+    /**
+     * Array of specific validation error messages
+     * Each message describes a single validation failure
+     */
+    readonly errors: string[];
+    /**
+     * Creates a new ValidationError
+     *
+     * @param message - Human-readable error message
+     * @param errors - Array of specific validation error messages
+     * @param context - Optional additional context
+     */
+    constructor(message: string, errors: string[], context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when an operation exceeds its timeout
+ *
+ * This includes request timeouts, polling timeouts, and any other time-bound
+ * operations. The timeout duration is included for debugging.
+ *
+ * @example
+ * ```typescript
+ * const timeout = 30000; // 30 seconds
+ * const timeoutPromise = new Promise((_, reject) => {
+ *   setTimeout(() => {
+ *     reject(new TimeoutError('Request timed out', timeout));
+ *   }, timeout);
+ * });
+ * await Promise.race([fetchPromise, timeoutPromise]);
+ * ```
+ *
+ * Requirement 5.3
+ */
+export declare class TimeoutError extends JackError {
+    /**
+     * The timeout duration in milliseconds
+     * Indicates how long the operation was allowed to run before timing out
+     */
+    readonly timeoutMs: number;
+    /**
+     * Creates a new TimeoutError
+     *
+     * @param message - Human-readable error message
+     * @param timeoutMs - The timeout duration in milliseconds
+     * @param context - Optional additional context
+     */
+    constructor(message: string, timeoutMs: number, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when retry attempts are exhausted
+ *
+ * This error is thrown after all retry attempts have failed. It includes the
+ * number of attempts made and the final error that caused the failure.
+ *
+ * @example
+ * ```typescript
+ * let lastError: Error;
+ * for (let attempt = 1; attempt <= maxRetries; attempt++) {
+ *   try {
+ *     return await makeRequest();
+ *   } catch (err) {
+ *     lastError = err as Error;
+ *     if (attempt === maxRetries) {
+ *       throw new RetryError(
+ *         'All retry attempts exhausted',
+ *         attempt,
+ *         lastError
+ *       );
+ *     }
+ *     await delay(retryDelay * Math.pow(retryBackoff, attempt - 1));
+ *   }
+ * }
+ * ```
+ *
+ * Requirement 5.3
+ */
+export declare class RetryError extends JackError {
+    /**
+     * The number of retry attempts that were made
+     * Includes the initial attempt plus all retries
+     */
+    readonly attempts: number;
+    /**
+     * The final error that caused the retry loop to fail
+     * This is the error from the last retry attempt
+     */
+    readonly lastError: Error;
+    /**
+     * Creates a new RetryError
+     *
+     * @param message - Human-readable error message
+     * @param attempts - The number of attempts that were made
+     * @param lastError - The final error from the last attempt
+     * @param context - Optional additional context
+     */
+    constructor(message: string, attempts: number, lastError: Error, context?: Record<string, unknown>);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC;;;OAGG;IACH,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAElD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAU/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC;;;OAGG;IACH,SAAgB,aAAa,EAAE,KAAK,CAAC;IAErC;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAKrF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC;;;OAGG;IACH,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC;;;OAGG;IACH,SAAgB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnC;;;;;;;OAOG;gBAED,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAQnC;;;OAGG;IACH,aAAa,IAAI,OAAO;IAIxB;;;OAGG;IACH,aAAa,IAAI,OAAO;IAIxB;;;;OAIG;IACH,WAAW,IAAI,OAAO;CAGvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC5C;;;OAGG;IACH,SAAgB,MAAM,EAAE,MAAM,EAAE,CAAC;IAEjC;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAKjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC;;;OAGG;IACH,SAAgB,SAAS,EAAE,MAAM,CAAC;IAElC;;;;;;OAMG;gBACS,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAKlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,UAAW,SAAQ,SAAS;IACvC;;;OAGG;IACH,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAEjC;;;OAGG;IACH,SAAgB,SAAS,EAAE,KAAK,CAAC;IAEjC;;;;;;;OAOG;gBAED,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,KAAK,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAOpC"}

package/dist/types/execution.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Execution tracking for the JACK SDK
+ *
+ * This module provides the ExecutionTracker class for polling intent status
+ * and waiting for specific execution states.
+ *
+ * Requirements: 2.1, 2.5
+ */
+import { ExecutionStatus, type Intent, type PollOptions, type ExecutionWatcher } from './types.js';
+import type { JackClient } from './client.js';
+/**
+ * Manager for execution tracking operations
+ *
+ * Provides methods to poll intent status, wait for specific statuses,
+ * and track execution progress with configurable timeouts.
+ *
+ * @example
+ * ```typescript
+ * const client = new JackClient({ baseUrl: 'https://api.jack.example' });
+ * const tracker = new ExecutionTracker(client);
+ *
+ * // Wait for intent to settle
+ * const intent = await tracker.waitForStatus(
+ *   'JK-ABC123456',
+ *   ExecutionStatus.SETTLED,
+ *   { timeout: 120000 }
+ * );
+ *
+ * console.log('Settlement tx:', intent.settlementTx);
+ * ```
+ */
+export declare class ExecutionTracker {
+    private readonly client;
+    /**
+     * Creates a new ExecutionTracker
+     *
+     * @param client - The JackClient instance to use for API requests
+     */
+    constructor(client: JackClient);
+    /**
+     * Get current status of an intent
+     *
+     * Queries the JACK API for the current intent status. This is a single
+     * request that returns the intent's current state without polling.
+     * This method delegates to the IntentManager's get() method.
+     *
+     * @param intentId - The intent ID to query (format: JK-[A-Z0-9]{9})
+     * @returns Promise resolving to the complete Intent object
+     * @throws APIError if the intent is not found (404) or other API error
+     * @throws NetworkError if the network request fails
+     *
+     * @example
+     * ```typescript
+     * const intent = await tracker.getStatus('JK-ABC123456');
+     * console.log('Current status:', intent.status);
+     * ```
+     *
+     * **Validates: Requirement 2.1**
+     */
+    getStatus(intentId: string): Promise<Intent>;
+    /**
+     * Wait for intent to reach a specific status
+     *
+     * Polls the intent status at regular intervals until it reaches one of the
+     * target statuses or the timeout is exceeded. This is useful for waiting
+     * for intent completion or specific state transitions.
+     *
+     * The polling loop will stop when:
+     * - The intent reaches one of the target statuses
+     * - The timeout is exceeded (throws TimeoutError)
+     * - An API error occurs (throws APIError)
+     *
+     * @param intentId - The intent ID to poll
+     * @param targetStatus - Single status or array of statuses to wait for
+     * @param options - Polling configuration (interval, timeout, stopStatuses)
+     * @returns Promise resolving to the Intent when target status is reached
+     * @throws TimeoutError if timeout is exceeded before reaching target status
+     * @throws APIError if the API returns an error
+     * @throws NetworkError if the network request fails
+     *
+     * @example
+     * ```typescript
+     * // Wait for settlement with custom timeout
+     * const intent = await tracker.waitForStatus(
+     *   'JK-ABC123456',
+     *   ExecutionStatus.SETTLED,
+     *   { interval: 3000, timeout: 120000 }
+     * );
+     *
+     * // Wait for any terminal status
+     * const intent = await tracker.waitForStatus(
+     *   'JK-ABC123456',
+     *   [ExecutionStatus.SETTLED, ExecutionStatus.ABORTED, ExecutionStatus.EXPIRED]
+     * );
+     * ```
+     *
+     * **Validates: Requirement 2.5**
+     */
+    waitForStatus(intentId: string, targetStatus: ExecutionStatus | ExecutionStatus[], options?: PollOptions): Promise<Intent>;
+    /**
+     * Create a watcher for continuous intent status updates
+     *
+     * Returns an ExecutionWatcher that polls the intent status at regular
+     * intervals and emits events when the status changes. This is useful for
+     * real-time monitoring of intent execution.
+     *
+     * The watcher will continue polling until:
+     * - stop() is called
+     * - A terminal status is reached (SETTLED, ABORTED, EXPIRED)
+     * - An error occurs (emitted via onError callback)
+     *
+     * @param intentId - The intent ID to watch
+     * @param options - Polling configuration (interval, timeout)
+     * @returns ExecutionWatcher instance with event callbacks
+     *
+     * @example
+     * ```typescript
+     * const watcher = tracker.watch('JK-ABC123456', { interval: 3000 });
+     *
+     * watcher.onUpdate((intent) => {
+     *   console.log('Status updated:', intent.status);
+     * });
+     *
+     * watcher.onComplete((intent) => {
+     *   console.log('Intent completed:', intent.settlementTx);
+     *   watcher.stop();
+     * });
+     *
+     * watcher.onError((error) => {
+     *   console.error('Polling error:', error);
+     * });
+     * ```
+     *
+     * **Validates: Requirements 2.2, 8.3**
+     */
+    watch(intentId: string, options?: PollOptions): ExecutionWatcher;
+    /**
+     * Sleep for specified milliseconds
+     *
+     * @param ms - Milliseconds to sleep
+     * @returns Promise that resolves after the specified delay
+     */
+    private sleep;
+}
+//# sourceMappingURL=execution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../src/execution.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IAEpC;;;;OAIG;gBACS,MAAM,EAAE,UAAU;IAI9B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,aAAa,CACjB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,GAAG,eAAe,EAAE,EACjD,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,MAAM,CAAC;IAoClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,gBAAgB;IAIhE;;;;;OAKG;IACH,OAAO,CAAC,KAAK;CAGd"}