@memoryintelligence/sdk 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,953 @@
+/**
+ * Enumerations for Memory Intelligence SDK
+ *
+ * These enums match the Python SDK exactly to ensure API compatibility.
+ */
+/**
+ * Governance scope for memory isolation.
+ * Scopes are cryptographic boundaries—data in one scope is
+ * technically inaccessible from another.
+ */
+declare enum Scope {
+    USER = "user",
+    CLIENT = "client",
+    PROJECT = "project",
+    TEAM = "team",
+    ORGANIZATION = "org",
+    ALL = "all"
+}
+/**
+ * What to retain after processing.
+ * Privacy by design: MEANING_ONLY is the default.
+ */
+declare enum RetentionPolicy {
+    MEANING_ONLY = "meaning_only",
+    FULL = "full",
+    SUMMARY_ONLY = "summary_only"
+}
+/**
+ * How to handle detected PII.
+ */
+declare enum PIIHandling {
+    DETECT_ONLY = "detect_only",
+    EXTRACT_AND_REDACT = "extract_and_redact",
+    HASH = "hash",
+    REJECT = "reject"
+}
+/**
+ * Provenance tracking level.
+ */
+declare enum ProvenanceMode {
+    STANDARD = "standard",
+    AUTHORSHIP = "authorship",
+    AUDIT = "audit"
+}
+/**
+ * Level of explanation to include in responses.
+ */
+declare enum ExplainLevel {
+    NONE = "none",
+    HUMAN = "human",
+    AUDIT = "audit",
+    FULL = "full"
+}
+
+/**
+ * Type definitions for Memory Intelligence SDK
+ *
+ * These types match the Python SDK models to ensure API compatibility.
+ */
+
+/**
+ * Entity extracted from content.
+ */
+interface Entity {
+    text: string;
+    type: string;
+    confidence?: number;
+}
+/**
+ * Topic extracted from content.
+ */
+interface Topic {
+    text: string;
+    relevance: number;
+}
+/**
+ * Embedding vector representation.
+ */
+interface Embedding {
+    vector: number[];
+    model: string;
+    dimensions: number;
+}
+/**
+ * Provenance information for a memory object.
+ */
+interface Provenance {
+    hash: string;
+    timestamp: string;
+    source?: string;
+    lineage?: string[];
+}
+/**
+ * Meaning Object - Core data structure.
+ * Raw content is discarded by default (retention_policy=MEANING_ONLY).
+ */
+interface MeaningObject {
+    umoId: string;
+    userUlid: string;
+    orgUlid?: string;
+    entities: Entity[];
+    topics: Topic[];
+    embedding: Embedding;
+    summary?: string;
+    provenance: Provenance;
+    createdAt: string;
+    scope: Scope;
+    scopeId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Search result containing a meaning object and relevance score.
+ */
+interface SearchResult {
+    umo: MeaningObject;
+    score: number;
+    explain?: Explanation;
+}
+/**
+ * Response from search endpoint.
+ */
+interface SearchResponse {
+    results: SearchResult[];
+    total: number;
+    query: string;
+    explain?: Explanation;
+}
+/**
+ * Match result comparing two meaning objects.
+ */
+interface MatchResult {
+    umoId1: string;
+    umoId2: string;
+    score: number;
+    semantic: number;
+    temporal?: number;
+    graph?: number;
+    explain?: Explanation;
+}
+/**
+ * Explanation of results (human + audit).
+ */
+interface Explanation {
+    human?: {
+        summary: string;
+        keyReasons: string[];
+        impact?: string;
+    };
+    audit?: {
+        semantic: number;
+        temporal?: number;
+        graph?: number;
+        entities?: number;
+        drift?: number;
+        formula: string;
+    };
+}
+/**
+ * Delete result response.
+ */
+interface DeleteResult {
+    deleted: number;
+    scope: Scope;
+    userUlid?: string;
+}
+/**
+ * Batch operation result for a single item.
+ */
+interface BatchItemResult {
+    index: number;
+    success: boolean;
+    umo?: MeaningObject;
+    error?: string;
+}
+/**
+ * Batch operation response.
+ */
+interface BatchResult {
+    results: BatchItemResult[];
+    totalProcessed: number;
+    totalSucceeded: number;
+    totalFailed: number;
+}
+/**
+ * Rate limit information from response headers.
+ */
+interface RateLimit {
+    limit?: number;
+    remaining?: number;
+    reset?: number;
+}
+/**
+ * HTTP response wrapper.
+ */
+interface SDKResponse<T> {
+    data: T;
+    rateLimit?: RateLimit;
+    requestId?: string;
+}
+
+/**
+ * HTTP client for Memory Intelligence SDK
+ *
+ * Provides fetch wrapper with:
+ * - Automatic retries
+ * - Rate limit handling
+ * - Error mapping
+ * - Request ID tracking
+ */
+
+interface HTTPClientConfig {
+    apiKey: string;
+    baseUrl: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+interface RequestOptions {
+    method?: string;
+    body?: unknown;
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}
+/**
+ * HTTP client with retry logic and error handling.
+ */
+declare class HTTPClient {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    private maxRetries;
+    constructor(config: HTTPClientConfig);
+    /**
+     * Make HTTP request with retry logic.
+     */
+    request<T>(endpoint: string, options?: RequestOptions): Promise<SDKResponse<T>>;
+    /**
+     * Make single HTTP request.
+     */
+    private makeRequest;
+    /**
+     * Extract rate limit information from response headers.
+     */
+    private extractRateLimit;
+    /**
+     * Handle error responses from API.
+     */
+    private handleErrorResponse;
+    /**
+     * Sleep utility for retry backoff.
+     */
+    private sleep;
+}
+
+/**
+ * WebSocket connection manager for Memory Intelligence SDK
+ *
+ * Handles persistent connections, auto-reconnect, and subscription routing.
+ */
+interface WebSocketConfig {
+    url: string;
+    apiKey: string;
+    orgUlid?: string;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+    pingInterval?: number;
+}
+interface SubscriptionMessage {
+    type: 'subscribe' | 'unsubscribe';
+    subscription_id: string;
+    stream: string;
+    filters?: Record<string, any>;
+    function_name?: string;
+    parameters?: Record<string, any>;
+}
+interface ServerMessage {
+    type: string;
+    subscription_id?: string;
+    [key: string]: any;
+}
+type MessageHandler = (message: ServerMessage) => void;
+/**
+ * WebSocket connection manager with auto-reconnect and subscription routing.
+ */
+declare class WebSocketManager {
+    private ws;
+    private config;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingIntervalId;
+    private subscriptions;
+    private connectionPromise;
+    private isConnecting;
+    private isClosed;
+    private onConnectHandlers;
+    private onDisconnectHandlers;
+    private onErrorHandlers;
+    constructor(config: WebSocketConfig);
+    /**
+     * Connect to WebSocket server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from WebSocket server.
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to a stream.
+     */
+    subscribe(message: SubscriptionMessage, handler: MessageHandler): Promise<void>;
+    /**
+     * Unsubscribe from a stream.
+     */
+    unsubscribe(subscriptionId: string): void;
+    /**
+     * Register connect event handler.
+     */
+    onConnect(handler: () => void): void;
+    /**
+     * Register disconnect event handler.
+     */
+    onDisconnect(handler: () => void): void;
+    /**
+     * Register error event handler.
+     */
+    onError(handler: (error: Error) => void): void;
+    /**
+     * Check if connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Send message to server.
+     */
+    private send;
+    /**
+     * Handle incoming message from server.
+     */
+    private handleMessage;
+    /**
+     * Start ping interval to keep connection alive.
+     */
+    private startPingInterval;
+    /**
+     * Stop ping interval.
+     */
+    private stopPingInterval;
+    /**
+     * Attempt to reconnect with exponential backoff.
+     */
+    private attemptReconnect;
+}
+
+/**
+ * Base subscription class for all WebSocket subscriptions.
+ */
+
+type EventHandler<T = any> = (data: T) => void;
+/**
+ * Base class for WebSocket subscriptions.
+ */
+declare abstract class BaseSubscription<T = any> {
+    protected subscriptionId: string;
+    protected ws: WebSocketManager;
+    protected eventHandlers: Map<string, EventHandler<T>[]>;
+    protected isActive: boolean;
+    constructor(ws: WebSocketManager);
+    /**
+     * Start the subscription.
+     */
+    abstract start(): Promise<void>;
+    /**
+     * Stop the subscription.
+     */
+    stop(): void;
+    /**
+     * Register an event handler.
+     */
+    on(event: string, handler: EventHandler<T>): this;
+    /**
+     * Remove an event handler.
+     */
+    off(event: string, handler: EventHandler<T>): this;
+    /**
+     * Emit an event to all registered handlers.
+     */
+    protected emit(event: string, data: T): void;
+    /**
+     * Handle incoming message from server.
+     */
+    protected abstract handleMessage(message: ServerMessage): void;
+    /**
+     * Generate unique subscription ID.
+     */
+    protected generateSubscriptionId(): string;
+    /**
+     * Check if subscription is active.
+     */
+    isSubscribed(): boolean;
+}
+
+/**
+ * Drift subscription for real-time entity meaning change notifications.
+ */
+
+interface DriftUpdate {
+    entityUlid: string;
+    canonicalName: string;
+    driftEpoch: number;
+    driftMagnitude: number;
+    meaningStable: boolean;
+    updatedAt: string;
+    explainHuman: {
+        driftSummary: string;
+        whatChanged: {
+            summary: string;
+            changes: string[];
+        };
+        impactOnResults: string;
+        confidenceAssessment: string;
+    };
+    signals: Array<{
+        signal: string;
+        magnitude: number;
+        isAnomalous: boolean;
+    }>;
+}
+interface DriftSubscriptionOptions {
+    entityUlids?: string[];
+    orgUlid?: string;
+}
+/**
+ * Subscription for drift updates on entities.
+ *
+ * Events:
+ * - 'update': (update: DriftUpdate) => void - New drift update received
+ * - 'connected': () => void - Subscription established
+ * - 'disconnected': () => void - Subscription closed
+ * - 'error': (error: Error) => void - Error occurred
+ */
+declare class DriftSubscription extends BaseSubscription<DriftUpdate> {
+    private options;
+    constructor(ws: WebSocketManager, options?: DriftSubscriptionOptions);
+    /**
+     * Start the drift subscription.
+     */
+    start(): Promise<void>;
+    /**
+     * Handle incoming drift update message.
+     */
+    protected handleMessage(message: ServerMessage): void;
+}
+
+/**
+ * Compute subscription for long-running operation progress and results.
+ */
+
+interface ComputeProgress {
+    status: 'analyzing' | 'processing' | 'finalizing';
+    progressPercent: number;
+    message: string;
+}
+interface ComputeResult<T = any> {
+    status: 'complete' | 'failed';
+    result?: T;
+    error?: string;
+    executionTimeMs: number;
+    explainHuman?: {
+        summary: string;
+        [key: string]: any;
+    };
+}
+type ComputeUpdate<T = any> = ComputeProgress | ComputeResult<T>;
+/**
+ * Subscription for long-running compute operations.
+ *
+ * Events:
+ * - 'progress': (progress: ComputeProgress) => void - Progress update
+ * - 'result': (result: ComputeResult) => void - Final result
+ * - 'connected': () => void - Subscription established
+ * - 'disconnected': () => void - Subscription closed
+ * - 'error': (error: Error) => void - Error occurred
+ */
+declare class ComputeSubscription<T = any> extends BaseSubscription<ComputeUpdate<T>> {
+    private functionName;
+    private parameters;
+    constructor(ws: WebSocketManager, functionName: string, parameters?: Record<string, any>);
+    /**
+     * Start the compute subscription.
+     */
+    start(): Promise<void>;
+    /**
+     * Handle incoming compute message.
+     */
+    protected handleMessage(message: ServerMessage): void;
+}
+
+/**
+ * Main client for Memory Intelligence SDK
+ *
+ * Provides the MemoryClient class and UMONamespace for all memory operations.
+ */
+
+interface MemoryClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    wsUrl?: string;
+    userUlid?: string;
+    orgUlid?: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+/**
+ * UMO Namespace - All memory operations under `mi.umo.*`
+ */
+declare class UMONamespace {
+    private client;
+    private http;
+    constructor(client: MemoryClient, http: HTTPClient);
+    /**
+     * Resolve user_ulid from explicit argument or client default.
+     */
+    private resolveUserUlid;
+    /**
+     * Process content into a Meaning Object.
+     *
+     * @param content - Raw text content to process
+     * @param options - Processing options
+     * @returns Meaning Object with entities, topics, embedding
+     */
+    process(content: string, options?: {
+        userUlid?: string;
+        retentionPolicy?: RetentionPolicy;
+        piiHandling?: PIIHandling;
+        provenanceMode?: ProvenanceMode;
+        scope?: Scope;
+        scopeId?: string;
+        source?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<MeaningObject>;
+    /**
+     * Search memories semantically.
+     *
+     * @param query - Natural language query
+     * @param options - Search options
+     * @returns Search results with relevance scores
+     */
+    search(query: string, options?: {
+        userUlid?: string;
+        limit?: number;
+        scope?: Scope;
+        scopeId?: string;
+        explain?: ExplainLevel;
+    }): Promise<SearchResponse>;
+    /**
+     * Match two memories for relevance.
+     *
+     * @param umoId1 - First meaning object ID
+     * @param umoId2 - Second meaning object ID
+     * @param options - Match options
+     * @returns Match score and breakdown
+     */
+    match(umoId1: string, umoId2: string, options?: {
+        explain?: ExplainLevel;
+    }): Promise<MatchResult>;
+    /**
+     * Get explanation for a memory.
+     *
+     * @param umoId - Meaning object ID
+     * @param level - Explanation detail level
+     * @returns Explanation with human and/or audit details
+     */
+    explain(umoId: string, level?: ExplainLevel): Promise<Explanation>;
+    /**
+     * Delete memories.
+     *
+     * @param options - Deletion options
+     * @returns Number of memories deleted
+     */
+    delete(options?: {
+        umoId?: string;
+        userUlid?: string;
+        scope?: Scope;
+    }): Promise<DeleteResult>;
+    /**
+     * Batch process multiple items.
+     *
+     * @param items - Array of items to process
+     * @returns Batch results with success/failure per item
+     */
+    batch(items: Array<{
+        content: string;
+        userUlid?: string;
+        metadata?: Record<string, unknown>;
+    }>): Promise<BatchResult>;
+}
+/**
+ * Drift Namespace - Real-time entity meaning change subscriptions
+ */
+declare class DriftNamespace {
+    private ws;
+    constructor(ws: WebSocketManager);
+    /**
+     * Watch for drift updates on specific entities.
+     *
+     * @param options - Subscription options (entity ULIDs, org filter)
+     * @returns DriftSubscription instance
+     *
+     * @example
+     * ```typescript
+     * const subscription = mi.drift.watch({
+     *   entityUlids: ['01ARZ3NDEV5ARZ3ND']
+     * });
+     *
+     * subscription.on('update', (update) => {
+     *   if (!update.meaningStable) {
+     *     console.log('Meaning changed:', update.explainHuman.driftSummary);
+     *   }
+     * });
+     *
+     * await subscription.start();
+     * ```
+     */
+    watch(options?: DriftSubscriptionOptions): DriftSubscription;
+}
+/**
+ * Compute Namespace - Long-running operation progress tracking
+ */
+declare class ComputeNamespace {
+    private ws;
+    constructor(ws: WebSocketManager);
+    /**
+     * Watch progress of a long-running compute operation.
+     *
+     * @param functionName - Name of compute function
+     * @param parameters - Function parameters
+     * @returns ComputeSubscription instance
+     *
+     * Disconnect WebSocket connections.
+     * Call this when shutting down the client.
+     */
+    disconnect(): void;
+    /**
+     * @example
+     * ```typescript
+     * const subscription = mi.compute.watch('analyze_decision_process', {
+     *   narrative_ulid: '01ARZ3NDFQ69G5FAVSV4RRFF'
+     * });
+     *
+     * subscription.on('progress', (progress) => {
+     *   console.log(`${progress.progressPercent}%: ${progress.message}`);
+     * });
+     *
+     * subscription.on('result', (result) => {
+     *   console.log('Complete:', result.result);
+     * });
+     *
+     * await subscription.start();
+     * ```
+     */
+    watch<T = any>(functionName: string, parameters?: Record<string, any>): ComputeSubscription<T>;
+}
+/**
+ * Main Memory Intelligence Client
+ *
+ * Usage:
+ * ```typescript
+ * const mi = new MemoryClient({ apiKey: 'mi_sk_beta_...' });
+ *
+ * // Search
+ * const results = await mi.umo.search('project planning');
+ *
+ * // Process
+ * const umo = await mi.umo.process('Important meeting notes');
+ *
+ * // Watch drift
+ * const driftSub = mi.drift.watch({ entityUlids: ['01ARZ...'] });
+ * await driftSub.start();
+ * ```
+ */
+declare class MemoryClient {
+    readonly userUlid?: string;
+    readonly orgUlid?: string;
+    readonly umo: UMONamespace;
+    readonly drift: DriftNamespace;
+    readonly compute: ComputeNamespace;
+    private http;
+    private ws;
+    constructor(config: MemoryClientConfig);
+    /**
+     * Create a new client instance with a different user context.
+     * Useful for multi-user scenarios.
+     *
+     * @param userUlid - User ULID for the new context
+     * @returns New MemoryClient instance
+     */
+    forUser(userUlid: string): MemoryClient;
+    /**
+     * Convenience alias for process (Batch 4.2)
+     */
+    capture(content: string, userUlid?: string): Promise<MeaningObject>;
+    /**
+     * Convenience alias for search (Batch 4.2)
+     */
+    search(query: string, limit?: number): Promise<SearchResponse>;
+    /**
+     * Convenience alias for explain (Batch 4.2)
+     */
+    explain(umoId: string): Promise<Explanation>;
+    /**
+     * Convenience alias for delete (Batch 4.2)
+     */
+    forget(umoId: string): Promise<DeleteResult>;
+}
+
+/**
+ * Streaming utilities for handling large datasets
+ *
+ * Provides:
+ * - Chunked response processing
+ * - Batch UMO processing
+ * - Memory-efficient iteration
+ * - Progress tracking
+ */
+
+interface StreamConfig {
+    /** Chunk size for batch operations */
+    chunkSize?: number;
+    /** Callback for progress updates */
+    onProgress?: (processed: number, total: number) => void;
+    /** Callback for chunk completion */
+    onChunk?: (chunk: any[], chunkIndex: number) => void;
+    /** Maximum concurrent operations */
+    concurrency?: number;
+}
+interface BatchProcessOptions {
+    /** Content items to process */
+    items: Array<{
+        content: string;
+        type?: string;
+        metadata?: Record<string, any>;
+    }>;
+    /** Streaming configuration */
+    config?: StreamConfig;
+}
+interface BatchSearchOptions {
+    /** Search queries to execute */
+    queries: string[];
+    /** Search options for each query */
+    searchOptions?: {
+        limit?: number;
+        filters?: Record<string, any>;
+    };
+    /** Streaming configuration */
+    config?: StreamConfig;
+}
+interface StreamIteratorOptions<T> {
+    /** Data source (array or async generator) */
+    source: T[] | AsyncGenerator<T>;
+    /** Chunk size for processing */
+    chunkSize: number;
+    /** Processing function for each chunk */
+    processor: (chunk: T[]) => Promise<void>;
+    /** Progress callback */
+    onProgress?: (processed: number) => void;
+}
+/**
+ * Streaming helper for batch UMO processing
+ */
+declare class UMOStreamProcessor {
+    private client;
+    constructor(client: MemoryClient);
+    /**
+     * Process multiple content items in batches
+     * to avoid overwhelming the API or memory.
+     */
+    processBatch(options: BatchProcessOptions): AsyncGenerator<MeaningObject, void, unknown>;
+    /**
+     * Process a chunk of items with concurrency control
+     */
+    private processChunk;
+    /**
+     * Execute multiple search queries in sequence
+     */
+    searchBatch(options: BatchSearchOptions): AsyncGenerator<{
+        query: string;
+        results: SearchResult[];
+    }, void, unknown>;
+    private sleep;
+}
+/**
+ * Generic streaming iterator for large datasets
+ */
+declare function streamLargeDataset<T>(options: StreamIteratorOptions<T>): AsyncGenerator<T[], void, unknown>;
+/**
+ * Helper for processing search results in streaming fashion
+ */
+declare class SearchResultStream {
+    private client;
+    constructor(client: MemoryClient);
+    /**
+     * Stream search results with pagination
+     */
+    paginate(query: string, options?: {
+        pageSize?: number;
+        maxResults?: number;
+        filters?: Record<string, any>;
+    }): AsyncGenerator<SearchResult[], void, unknown>;
+}
+/**
+ * Progress tracker for streaming operations
+ */
+declare class ProgressTracker {
+    private total;
+    private processed;
+    private startTime;
+    private onUpdate?;
+    constructor(total: number, onUpdate?: (progress: ProgressUpdate) => void);
+    update(count?: number): void;
+    getProgress(): ProgressUpdate;
+}
+interface ProgressUpdate {
+    processed: number;
+    total: number;
+    percentage: number;
+    elapsed: number;
+    rate: number;
+    eta?: number;
+}
+
+/**
+ * React Native Compatibility Layer
+ *
+ * Ensures the SDK works correctly in React Native environments
+ * by detecting and polyfilling missing APIs.
+ *
+ * Usage:
+ * ```typescript
+ * import { checkReactNativeCompatibility, setupReactNativePolyfills } from '@memoryintelligence/sdk/react-native';
+ *
+ * // In your app entry point (App.tsx)
+ * const compatibility = checkReactNativeCompatibility();
+ * if (!compatibility.compatible) {
+ *   console.warn('Missing APIs:', compatibility.missing);
+ *   setupReactNativePolyfills(); // Auto-install available polyfills
+ * }
+ * ```
+ */
+interface CompatibilityCheck {
+    compatible: boolean;
+    missing: string[];
+    warnings: string[];
+    polyfillsAvailable: string[];
+}
+interface ReactNativeConfig {
+    /** Custom fetch implementation */
+    fetch?: typeof fetch;
+    /** Custom WebSocket implementation */
+    WebSocket?: typeof WebSocket;
+    /** Custom crypto implementation */
+    crypto?: any;
+    /** Custom Text encoder implementation */
+    TextEncoder?: typeof TextEncoder;
+    /** Custom Text decoder implementation */
+    TextDecoder?: typeof TextDecoder;
+}
+/**
+ * Check if the current environment is React Native compatible
+ */
+declare function checkReactNativeCompatibility(): CompatibilityCheck;
+/**
+ * Automatically setup polyfills for React Native
+ *
+ * Note: This requires the polyfill packages to be installed:
+ * ```bash
+ * npm install whatwg-fetch react-native-get-random-values abortcontroller-polyfill text-encoding
+ * ```
+ */
+declare function setupReactNativePolyfills(): void;
+/**
+ * Create a configured MemoryClient for React Native
+ */
+declare function createReactNativeClient(apiKey: string, options?: ReactNativeConfig & {
+    baseUrl?: string;
+}): any;
+/**
+ * React Native specific utilities
+ */
+declare const ReactNativeUtils: {
+    /**
+     * Check if running in React Native environment
+     */
+    isReactNative(): boolean;
+    /**
+     * Get recommended polyfill packages for current environment
+     */
+    getRecommendedPolyfills(): string[];
+    /**
+     * Generate installation command for missing polyfills
+     */
+    getInstallCommand(): string | null;
+};
+/**
+ * Type guard to check if error is a polyfill error
+ */
+declare function isPolyfillError(error: unknown): boolean;
+/**
+ * Helper to provide detailed polyfill error messages
+ */
+declare function getPolyfillErrorHelp(error: unknown): string | null;
+
+/**
+ * Error classes for Memory Intelligence SDK
+ *
+ * All errors extend SDKError for consistency with Python SDK patterns.
+ */
+declare class SDKError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+declare class ConfigurationError extends SDKError {
+    constructor(message: string);
+}
+declare class AuthenticationError extends SDKError {
+    constructor(message: string);
+}
+declare class ValidationError extends SDKError {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+declare class RateLimitError extends SDKError {
+    retryAfter?: number | undefined;
+    limit?: number | undefined;
+    remaining?: number | undefined;
+    constructor(message: string, retryAfter?: number | undefined, limit?: number | undefined, remaining?: number | undefined);
+}
+declare class APIError extends SDKError {
+    statusCode?: number | undefined;
+    requestId?: string | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, statusCode?: number | undefined, requestId?: string | undefined, details?: unknown | undefined);
+}
+
+/**
+ * Memory Intelligence JavaScript/TypeScript SDK
+ *
+ * Official SDK for building web apps, Node.js services, and edge functions
+ * powered by Memory Intelligence.
+ *
+ * @packageDocumentation
+ */
+
+declare const VERSION = "2.0.0";
+
+export { APIError, AuthenticationError, BaseSubscription, type BatchItemResult, type BatchProcessOptions, type BatchResult, type BatchSearchOptions, type CompatibilityCheck, ComputeNamespace, type ComputeProgress, type ComputeResult, ComputeSubscription, type ComputeUpdate, ConfigurationError, type DeleteResult, DriftNamespace, DriftSubscription, type DriftSubscriptionOptions, type DriftUpdate, type Embedding, type Entity, type EventHandler, ExplainLevel, type Explanation, type MatchResult, type MeaningObject, MemoryClient, type MemoryClientConfig, PIIHandling, ProgressTracker, type ProgressUpdate, type Provenance, ProvenanceMode, type RateLimit, RateLimitError, type ReactNativeConfig, ReactNativeUtils, RetentionPolicy, SDKError, type SDKResponse, Scope, type SearchResponse, type SearchResult, SearchResultStream, type ServerMessage, type StreamConfig, type StreamIteratorOptions, type SubscriptionMessage, type Topic, UMONamespace, UMOStreamProcessor, VERSION, ValidationError, type WebSocketConfig, WebSocketManager, checkReactNativeCompatibility, createReactNativeClient, getPolyfillErrorHelp, isPolyfillError, setupReactNativePolyfills, streamLargeDataset };