@lanonasis/mem-intel-sdk 1.1.0 → 2.0.0

package/CHANGELOG.md

@@ -5,6 +5,171 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+---
+
+## [2.0.0] - 2026-01-13
+
+### The AI That Anticipates What You Need
+
+This major release introduces the **Predictive Memory System** - the flagship Phase 2 feature that makes your memory system feel magical. Instead of just storing and retrieving memories, the SDK now **predicts what you'll need before you realize it**.
+
+### Added
+
+#### Predictive Memory System (Phase 2A)
+
+- **`predictiveRecall()`** - AI-powered prediction of memories based on current context
+- **Weighted Scoring Algorithm**:
+  - Semantic similarity to current context (40%)
+  - Temporal relevance with Ebbinghaus decay curve (30%)
+  - Usage frequency, logarithmically scaled (20%)
+  - Serendipity factor for adjacent discoveries (10%)
+- **Explainable Predictions** - Every prediction includes:
+  - Confidence score (0-100)
+  - Human-readable reason ("Highly relevant to your current work")
+  - Score breakdown for transparency
+  - Suggested action (apply, review, explore, reference)
+
+#### Personalization
+
+- **User Profile Integration** - Fetches first name, email, organization for personalized responses
+- **Personalized Greetings** - "Sarah, here's what you might need" instead of generic messages
+- **Contextual Feedback** - "Thanks Sarah! We'll use this to improve your predictions."
+
+#### Premium Tier Gating
+
+- **`checkPremiumAccess()`** - Validate feature access by subscription tier
+- **Tier-Based Access Control** - Free, Pro, Business, Enterprise tiers
+- **Feature Flags** - Granular per-feature access control
+- **Graceful Degradation** - If checks fail, defaults to allowing access
+
+#### Prediction Feedback Loop
+
+- **`recordPredictionFeedback()`** - Track if predictions were useful
+- **`getPredictionMetrics()`** - Dashboard metrics for prediction accuracy
+- **Access Count Updates** - Predictions that get clicked/saved improve frequency scoring
+
+#### MCP Tools
+
+- **`memory_predictive_recall`** - Full MCP tool with markdown formatting
+- **`memory_prediction_feedback`** - Record user feedback on predictions
+
+#### React Integration
+
+```tsx
+// New hooks for predictions
+const { data } = usePredictiveRecall({
+  userId: "user-123",
+  context: {
+    currentProject: "Building dashboard",
+    recentTopics: ["React", "performance"]
+  }
+});
+
+// Feedback hook
+const { mutate: recordFeedback } = usePredictionFeedback();
+```
+
+#### Vue Integration
+
+```vue
+<script setup>
+const { data, execute } = usePredictiveRecall();
+const { execute: recordFeedback } = usePredictionFeedback();
+</script>
+```
+
+#### Database Infrastructure
+
+New migration file `supabase/migrations/20260113_prediction_system.sql` includes:
+
+| Component | Purpose |
+|-----------|---------|
+| `prediction_feedback` table | Track prediction accuracy |
+| `prediction_history` table | Audit log of predictions |
+| `increment_access_count()` | Update frequency scores |
+| `get_user_profile_for_predictions()` | Personalization data |
+| `has_premium_feature()` | Tier-based access control |
+| `get_prediction_accuracy()` | Metrics calculation |
+
+### Changed
+
+- **Version bump** - 1.1.0 → 2.0.0 (major version for significant new capabilities)
+- **Package description** - Updated to highlight predictive recall
+- **Keywords** - Added: predictive, predictions, embeddings, vector-search, personalization, machine-learning
+
+### Technical Details
+
+#### Prediction Algorithm
+
+```
+Combined Score = (Semantic × 40%) + (Temporal × 30%) + (Frequency × 20%) + (Serendipity × 10%)
+```
+
+- **Semantic**: Cosine similarity between context embedding and memory embedding
+- **Temporal**: Exponential decay (Ebbinghaus forgetting curve, 14-day half-life)
+- **Frequency**: Logarithmic scaling of access counts (prevents outliers from dominating)
+- **Serendipity**: "Adjacent possible" - rewards nearby-but-not-identical topics (0.3-0.6 similarity range)
+
+#### Context Types
+
+```typescript
+interface PredictiveContext {
+  currentProject?: string;    // "Building dashboard components"
+  recentTopics?: string[];    // ["React", "TypeScript", "performance"]
+  activeFiles?: string[];     // ["/src/Dashboard.tsx"]
+  contextText?: string;       // Free-form: "Optimizing render performance"
+  teamContext?: string;       // "Team discussing caching strategies"
+}
+```
+
+### Migration Guide
+
+1. **Run database migration**:
+   ```bash
+   # Copy SQL from supabase/migrations/20260113_prediction_system.sql
+   # Execute in Supabase SQL Editor
+   ```
+
+2. **Enable for users** (optional premium gating):
+   ```sql
+   UPDATE profiles
+   SET subscription_tier = 'pro',
+       feature_flags = '{"predictive_recall": true}'::jsonb
+   WHERE id = 'user-uuid';
+   ```
+
+3. **Use new methods**:
+   ```typescript
+   // Before (1.x) - manual search
+   const related = await client.findRelated({ memoryId, userId });
+
+   // After (2.x) - AI anticipates what you need
+   const predictions = await client.predictiveRecall({
+     userId,
+     context: { currentProject: "My current work" }
+   });
+   ```
+
+---
+
+## [1.1.0] - 2025-12-20
+
+### Added
+
+- **Behavioral Intelligence Foundation** (Context Patterns v2.0)
+- `recordBehavior()` - Store workflow patterns
+- `recallBehavior()` - Query patterns with local-first approach
+- `suggestBehavior()` - AI-powered next action suggestions
+- WorkflowPattern type with trigger, context, actions, outcome tracking
+
+### Improved
+
+- Enhanced offline-fallback caching
+- Better error messages for API failures
+- Response adapter handles both Edge Function envelope and direct responses
+
+---
+
 ## [1.0.1] - 2025-12-18
 
 ### Fixed
@@ -20,25 +185,75 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Improved error messages in core error classes
 - Better handling of OpenAI client initialization
 
+---
+
 ## [1.0.0] - 2024-12-17
 
+### Initial Release
+
+The first release of `@lanonasis/mem-intel-sdk` - an AI-powered memory intelligence SDK for the LanOnasis Memory-as-a-Service platform.
+
 ### Added
 
-- Initial release of `@lanonasis/mem-intel-sdk`
-- Core `MemoryIntelligenceClient` with API-based architecture
-- Framework integrations:
-  - React hooks with React Query integration (`/react`)
+#### Core Features
+
+- **`MemoryIntelligenceClient`** - Universal API client with offline-fallback capability
+- **Framework Integrations**:
+  - React hooks with React Query (`/react`)
   - Vue composables (`/vue`)
   - Node.js optimized client (`/node`)
   - MCP Server creation (`/server`)
-- Memory intelligence features:
-  - `analyzePatterns` - Analyze usage patterns and trends
-  - `suggestTags` - AI-powered tag suggestions
-  - `findRelated` - Semantic similarity search
-  - `detectDuplicates` - Duplicate memory detection
-  - `extractInsights` - Extract insights from memories
-  - `healthCheck` - Memory collection health analysis
-- TypeScript support with full type definitions
-- Support for both ESM and CommonJS
-- Comprehensive error handling with custom error classes
-- Dual response format support (JSON and Markdown)
+
+#### Intelligence Tools
+
+| Tool | Description |
+|------|-------------|
+| `analyzePatterns` | Understand usage trends and productivity patterns |
+| `suggestTags` | AI-powered tag suggestions with confidence scores |
+| `findRelated` | Find semantically related memories using vector similarity |
+| `detectDuplicates` | Identify duplicate or near-duplicate memories |
+| `extractInsights` | Extract key learnings from your knowledge base |
+| `healthCheck` | Analyze organization quality with actionable recommendations |
+
+#### Developer Experience
+
+- Full TypeScript support with comprehensive type definitions
+- Dual module support (ESM and CommonJS)
+- Custom error classes for better debugging
+- Dual response format (JSON and Markdown)
+- Zod schema validation for MCP tools
+
+---
+
+## Roadmap
+
+### Coming in 2.1.0 (Q1 2026)
+
+- **Knowledge Gap Detection** - "What should I learn next?"
+- Personalized learning paths based on your saved memories
+- Integration with YouTube, Medium, Dev.to for resources
+
+### Coming in 2.2.0 (Q2 2026)
+
+- **Team Knowledge Graph** - "Who's the expert on X?"
+- Privacy-first aggregation (no individual data exposed)
+- Expert finder with topic expertise scoring
+
+### Coming in 3.0.0 (Q3 2026)
+
+- **Privacy-First Local Processing** - ONNX Runtime on-device
+- **Autonomous Organization Agent** - Weekly AI cleanup
+- **API Marketplace** - Developer ecosystem with 70/30 revenue share
+
+---
+
+## Links
+
+- [GitHub Repository](https://github.com/lanonasis/memory-intelligence-engine)
+- [npm Package](https://www.npmjs.com/package/@lanonasis/mem-intel-sdk)
+- [Product Roadmap](./PRODUCT-ROADMAP-2025-2026.md)
+- [Migration Guide](./supabase/migrations/20260113_prediction_system.sql)
+
+---
+
+Built with care by the LanOnasis team. We believe AI should anticipate your needs, not just respond to commands.

package/README.md

@@ -2,11 +2,40 @@
 
 [![npm version](https://badge.fury.io/js/%40lanonasis%2Fmem-intel-sdk.svg)](https://www.npmjs.com/package/@lanonasis/mem-intel-sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue.svg)](https://www.typescriptlang.org/)
+[![Tests](https://img.shields.io/badge/tests-89%20passing-brightgreen.svg)]()
 
-An AI-powered memory intelligence SDK for the LanOnasis Memory-as-a-Service platform. Provides advanced analytics, insights, and intelligent organization features.
+**The AI that anticipates what you need before you realize it.**
+
+An AI-powered memory intelligence SDK for the LanOnasis Memory-as-a-Service platform. Beyond storage and retrieval - this SDK **predicts** what memories you'll need based on your current context.
+
+```typescript
+// The magic moment
+const predictions = await client.predictiveRecall({
+  userId: "user-123",
+  context: {
+    currentProject: "Building dashboard components",
+    recentTopics: ["React", "performance"]
+  }
+});
+
+// "Sarah, here's what you might need"
+// [92%] React Hooks Performance Optimization
+//       → Reason: Highly relevant to your current work
+//       → Action: Apply
+```
 
 ## Features
 
+### NEW in v2.0.0: Predictive Memory System
+
+- **Predictive Recall** - AI anticipates what you'll need before you search
+- **Personalized Responses** - "Sarah, here's what you might need"
+- **Explainable Predictions** - Every suggestion includes confidence score and reasoning
+- **Learning Loop** - Feedback improves future predictions
+
+### Core Intelligence
+
 - **Pattern Recognition** - Understand usage trends and productivity patterns
 - **Smart Organization** - AI-powered tag suggestions and duplicate detection
 - **Semantic Intelligence** - Find related memories using vector similarity
@@ -126,6 +155,129 @@ onMounted(() => {
 </script>
 ```
 
+## Predictive Memory System (v2.0.0)
+
+The flagship feature that makes your memory system feel magical.
+
+### How It Works
+
+```
+                    Your Current Context
+                           │
+                           ▼
+    ┌──────────────────────────────────────────┐
+    │         PREDICTION ENGINE                 │
+    │                                           │
+    │  Semantic (40%)  ─┐                       │
+    │  Temporal (30%)  ─┼──► Combined Score    │
+    │  Frequency (20%) ─┤                       │
+    │  Serendipity (10%)┘                       │
+    └──────────────────────────────────────────┘
+                           │
+                           ▼
+              "Here's what you'll need"
+```
+
+### Basic Usage
+
+```typescript
+const predictions = await client.predictiveRecall({
+  userId: "user-123",
+  context: {
+    currentProject: "Building dashboard components",
+    recentTopics: ["React", "TypeScript", "performance"],
+    activeFiles: ["/src/components/Dashboard.tsx"],
+    contextText: "Optimizing render performance for data tables"
+  },
+  limit: 5,
+  minConfidence: 50
+});
+
+// Each prediction includes:
+for (const pred of predictions.data.predictions) {
+  console.log(`[${pred.confidence}%] ${pred.title}`);
+  console.log(`  Why: ${pred.reason}`);
+  console.log(`  Action: ${pred.suggestedAction}`);
+  console.log(`  Scores: semantic=${pred.scoreBreakdown.semanticScore}, temporal=${pred.scoreBreakdown.temporalScore}`);
+}
+```
+
+### With Personalization
+
+```typescript
+// Response includes personalized greeting
+const result = await client.predictiveRecall({
+  userId: "user-123",
+  context: { currentProject: "My project" }
+});
+
+console.log(result.personalization?.greeting);
+// → "Sarah, here's what you might need"
+
+console.log(result.personalization?.tier);
+// → "pro"
+```
+
+### Recording Feedback (Improves Future Predictions)
+
+```typescript
+// When user clicks on a prediction
+await client.recordPredictionFeedback({
+  memoryId: prediction.id,
+  userId: "user-123",
+  useful: true,
+  action: "clicked"
+});
+// → { success: true, message: "Thanks Sarah! We'll use this to improve your predictions." }
+```
+
+### React Hook
+
+```tsx
+import { usePredictiveRecall, usePredictionFeedback } from "@lanonasis/mem-intel-sdk/react";
+
+function PredictionsPanel({ userId }) {
+  const { data, isLoading } = usePredictiveRecall({
+    userId,
+    context: {
+      currentProject: "Dashboard",
+      recentTopics: ["React", "charts"]
+    }
+  });
+
+  const { mutate: recordFeedback } = usePredictionFeedback();
+
+  if (isLoading) return <div>Finding relevant memories...</div>;
+
+  return (
+    <div>
+      <h2>{data?.personalization?.greeting}</h2>
+      {data?.predictions.map(pred => (
+        <div key={pred.id} onClick={() => recordFeedback({
+          memoryId: pred.id,
+          userId,
+          useful: true,
+          action: "clicked"
+        })}>
+          <span className="confidence">{pred.confidence}%</span>
+          <h3>{pred.title}</h3>
+          <p>{pred.reason}</p>
+        </div>
+      ))}
+    </div>
+  );
+}
+```
+
+### Scoring Algorithm
+
+| Factor | Weight | Description |
+|--------|--------|-------------|
+| **Semantic** | 40% | Cosine similarity between context embedding and memory embedding |
+| **Temporal** | 30% | Exponential decay (Ebbinghaus curve, 14-day half-life) |
+| **Frequency** | 20% | Logarithmic scaling of access counts |
+| **Serendipity** | 10% | Bonus for "adjacent possible" discoveries (0.3-0.6 similarity) |
+
 ## Overview
 
 This SDK is designed to **complement** your existing `@lanonasis/mcp-core` infrastructure by adding an intelligence layer on top of basic memory CRUD operations. While your core server handles memory creation, storage, and retrieval, this SDK focuses on:
@@ -341,6 +493,54 @@ Analyze the organization quality of your memory collection.
 - Type balance analysis
 - Actionable recommendations
 
+---
+
+### 7. `memory_predictive_recall` (NEW in v2.0.0)
+
+AI-powered prediction of memories you'll need based on current context.
+
+```json
+{
+  "user_id": "uuid",
+  "context": {
+    "current_project": "Building dashboard components",
+    "recent_topics": ["React", "performance"],
+    "context_text": "Optimizing render performance"
+  },
+  "limit": 5,
+  "min_confidence": 50,
+  "include_serendipity": true
+}
+```
+
+**Returns:**
+
+- Predicted memories with confidence scores
+- Human-readable explanations
+- Score breakdown (semantic, temporal, frequency, serendipity)
+- Suggested actions (apply, review, explore, reference)
+- Personalized greeting with user's name
+
+---
+
+### 8. `memory_prediction_feedback` (NEW in v2.0.0)
+
+Record feedback on predictions to improve accuracy over time.
+
+```json
+{
+  "memory_id": "uuid",
+  "user_id": "uuid",
+  "useful": true,
+  "action": "clicked"
+}
+```
+
+**Returns:**
+
+- Personalized thank you message
+- Feedback confirmation
+
 ## Integration with @lanonasis/mcp-core
 
 This server is designed to work alongside your existing infrastructure:
@@ -470,11 +670,30 @@ Your Supabase database must have:
 | **Testing**        | Complex integration tests  | Focused unit tests         |
 | **Reusability**    | Tied to LanOnasis          | Portable to other projects |
 
-## Future Enhancements
+## What's Next
+
+### v2.1.0 - Knowledge Gap Detection (Q1 2026)
+
+- [ ] "What should I learn next?" recommendations
+- [ ] Personalized learning paths
+- [ ] Integration with YouTube, Medium, Dev.to
+
+### v2.2.0 - Team Knowledge Graph (Q2 2026)
+
+- [ ] "Who's the expert on X?" finder
+- [ ] Privacy-first team aggregation
+- [ ] Expertise scoring and visualization
+
+### v3.0.0 - Market Leadership (Q3 2026)
+
+- [ ] Privacy-first local processing (ONNX Runtime)
+- [ ] Autonomous organization agent
+- [ ] API marketplace with 70/30 revenue share
+
+### Backlog
 
 - [ ] Memory clustering with topic detection
 - [ ] Automatic summarization of memory collections
-- [ ] Knowledge graph visualization
 - [ ] Anomaly detection in memory patterns
 - [ ] Content quality scoring
 - [ ] Multi-language support
@@ -510,10 +729,45 @@ npm publish --access public
 
 Contributions are welcome! Please feel free to submit a Pull Request.
 
+## Database Setup (v2.0.0)
+
+For predictive recall features, run the migration:
+
+```bash
+# Option 1: Supabase CLI
+supabase db push
+
+# Option 2: Copy SQL to Supabase SQL Editor
+# File: supabase/migrations/20260113_prediction_system.sql
+```
+
+This creates:
+
+- `prediction_feedback` - Track prediction accuracy
+- `prediction_history` - Audit log
+- `increment_access_count()` - Frequency scoring
+- `get_user_profile_for_predictions()` - Personalization
+- `has_premium_feature()` - Premium tier gating
+- `get_prediction_accuracy()` - Metrics
+
+### Premium Tier Setup (Optional)
+
+```sql
+-- Enable predictive recall for a user
+UPDATE profiles
+SET subscription_tier = 'pro',
+    feature_flags = '{"predictive_recall": true}'::jsonb
+WHERE id = 'user-uuid';
+```
+
 ## License
 
 MIT License - See [LICENSE](./LICENSE) for details.
 
 ---
 
-Built with ❤️ for the LanOnasis platform by following MCP best practices.
+**Built with care by the LanOnasis team.**
+
+We believe AI should anticipate your needs, not just respond to commands.
+
+[GitHub](https://github.com/lanonasis/memory-intelligence-engine) | [npm](https://www.npmjs.com/package/@lanonasis/mem-intel-sdk) | [Changelog](./CHANGELOG.md)

package/dist/core/client.d.ts

@@ -3,6 +3,7 @@
  * Supports API-first with offline-fallback capability
  */
 import { MemoryIntelligenceConfig, AnalyzePatternsParams, PatternAnalysis, SuggestTagsParams, TagSuggestionsResult, FindRelatedParams, RelatedMemoriesResult, DetectDuplicatesParams, DuplicatesResult, ExtractInsightsParams, InsightsResult, HealthCheckParams, MemoryHealth, QueryMemoriesOptions, MemoryEntry, ProcessingMode } from "./types.js";
+import { PredictiveRecallParams, PredictiveRecallResult } from "./prediction-types.js";
 import { HttpClient } from "../utils/http-client.js";
 import { UsageInfo, TierInfo } from "../utils/response-adapter.js";
 export interface IntelligenceResponse<T> {
@@ -60,5 +61,55 @@ export declare class MemoryIntelligenceClient {
      * Check the health and organization quality of memories
      */
     healthCheck(params: HealthCheckParams): Promise<IntelligenceResponse<MemoryHealth>>;
+    /**
+     * Predictive Memory Recall - AI that anticipates what you need
+     *
+     * Uses a weighted scoring algorithm:
+     *   - Semantic similarity to current context (40%)
+     *   - Temporal relevance (recency decay curve) (30%)
+     *   - Usage frequency (20%)
+     *   - Serendipity factor (adjacent discoveries) (10%)
+     *
+     * @example
+     * ```typescript
+     * const result = await client.predictiveRecall({
+     *   userId: "user-123",
+     *   context: {
+     *     currentProject: "Building dashboard components",
+     *     recentTopics: ["React", "performance", "hooks"],
+     *     contextText: "Optimizing render performance for data tables"
+     *   },
+     *   limit: 5,
+     *   minConfidence: 50
+     * });
+     *
+     * for (const prediction of result.data.predictions) {
+     *   console.log(`[${prediction.confidence}%] ${prediction.title}`);
+     *   console.log(`  Reason: ${prediction.reason}`);
+     *   console.log(`  Action: ${prediction.suggestedAction}`);
+     * }
+     * ```
+     */
+    predictiveRecall(params: PredictiveRecallParams): Promise<IntelligenceResponse<PredictiveRecallResult>>;
+    /**
+     * Record feedback on a prediction (for improving accuracy over time)
+     *
+     * @example
+     * ```typescript
+     * await client.recordPredictionFeedback({
+     *   memoryId: "mem-123",
+     *   userId: "user-123",
+     *   useful: true,
+     *   action: "clicked"
+     * });
+     * ```
+     */
+    recordPredictionFeedback(params: {
+        memoryId: string;
+        userId: string;
+        useful: boolean;
+        action: "clicked" | "saved" | "dismissed" | "ignored";
+        dismissReason?: "not_relevant" | "already_know" | "not_now" | "other";
+    }): Promise<void>;
 }
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/core/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,oBAAoB,EACpB,WAAW,EACX,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAInE,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,qBAAqB,CAAsB;IACnD,OAAO,CAAC,cAAc,CAAiB;gBAE3B,MAAM,EAAE,wBAAwB;IAuB5C;;OAEG;IACH,iBAAiB,IAAI,cAAc;IAInC;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACI,aAAa,IAAI,UAAU;IAIlC;;OAEG;IACU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,WAAW,EAAE,CAAC;IAwBzB;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,eAAe,CAAC,CAAC;IAqBpG;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;IAqBjG;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;IAqBlG;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;IAqBvG;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC;IAqBnG;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC;CAoB1F"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/core/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,oBAAoB,EACpB,WAAW,EACX,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAInE,MAAM,WAAW,oBAAoB,CAAC,CAAC;IACrC,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,qBAAqB,CAAsB;IACnD,OAAO,CAAC,cAAc,CAAiB;gBAE3B,MAAM,EAAE,wBAAwB;IAuB5C;;OAEG;IACH,iBAAiB,IAAI,cAAc;IAInC;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACI,aAAa,IAAI,UAAU;IAIlC;;OAEG;IACU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,WAAW,EAAE,CAAC;IAwBzB;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,eAAe,CAAC,CAAC;IAqBpG;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;IAqBjG;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;IAqBlG;;OAEG;IACG,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;IAqBvG;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC;IAqBnG;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC;IAqBzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,gBAAgB,CACpB,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;IA2BxD;;;;;;;;;;;;OAYG;IACG,wBAAwB,CAAC,MAAM,EAAE;QACrC,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,CAAC;QACtD,aAAa,CAAC,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,GAAG,OAAO,CAAC;KACvE,GAAG,OAAO,CAAC,IAAI,CAAC;CAGlB"}