@axonflow/sdk 1.2.0 → 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AxonFlow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,10 @@
 # AxonFlow SDK for TypeScript
 
+[![npm version](https://img.shields.io/npm/v/@axonflow/sdk.svg)](https://www.npmjs.com/package/@axonflow/sdk)
+[![npm downloads](https://img.shields.io/npm/dm/@axonflow/sdk.svg)](https://www.npmjs.com/package/@axonflow/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.0-blue.svg)](https://www.typescriptlang.org/)
+
 Add invisible AI governance to your applications in 3 lines of code. No UI changes. No user training. Just drop-in enterprise protection.
 
 ## Installation
@@ -10,7 +15,7 @@ npm install @axonflow/sdk
 
 ## Quick Start
 
-### Basic Usage
+### Basic Usage (License-Based Auth)
 
 ```typescript
 import { AxonFlow } from '@axonflow/sdk';
@@ -19,8 +24,10 @@ import OpenAI from 'openai';
 // Initialize your AI client as usual
 const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
-// Add AxonFlow governance (3 lines)
-const axonflow = new AxonFlow({ apiKey: process.env.AXONFLOW_API_KEY });
+// Add AxonFlow governance with license key (recommended)
+const axonflow = new AxonFlow({
+  licenseKey: process.env.AXONFLOW_LICENSE_KEY
+});
 
 // Wrap any AI call with protect()
 const response = await axonflow.protect(async () => {
@@ -38,7 +45,9 @@ import { AxonFlow, wrapOpenAIClient } from '@axonflow/sdk';
 import OpenAI from 'openai';
 
 const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-const axonflow = new AxonFlow({ apiKey: process.env.AXONFLOW_API_KEY });
+const axonflow = new AxonFlow({
+  licenseKey: process.env.AXONFLOW_LICENSE_KEY
+});
 
 // Wrap the entire client - all calls are now protected
 const protectedOpenAI = wrapOpenAIClient(openai, axonflow);
@@ -50,13 +59,185 @@ const response = await protectedOpenAI.chat.completions.create({
 });
 ```
 
+### Self-Hosted Mode (No License Required)
+
+Connect to a self-hosted AxonFlow instance running via docker-compose:
+
+```typescript
+import { AxonFlow } from '@axonflow/sdk';
+import OpenAI from 'openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+// Self-hosted (localhost) - no license key needed!
+const axonflow = new AxonFlow({
+  endpoint: 'http://localhost:8081'
+  // That's it - no authentication required for localhost
+});
+
+// Use normally - same features as production
+const response = await axonflow.protect(async () => {
+  return openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: 'Test with self-hosted AxonFlow' }]
+  });
+});
+```
+
+**Self-hosted deployment:**
+```bash
+# Clone and start AxonFlow
+git clone https://github.com/getaxonflow/axonflow.git
+cd axonflow
+export OPENAI_API_KEY=sk-your-key-here
+docker-compose up
+
+# SDK connects to http://localhost:8081 - no license needed!
+```
+
+**Features:**
+- ✅ Full AxonFlow features without license
+- ✅ Perfect for local development and testing
+- ✅ Same API as production
+- ✅ Automatically detects localhost and skips authentication
+
+### Legacy API Key Auth (Deprecated)
+
+> **⚠️ Deprecated**: `apiKey` authentication is deprecated. Please migrate to license-based authentication using `licenseKey`.
+
+```typescript
+// Legacy method (still supported for backward compatibility)
+const axonflow = new AxonFlow({ apiKey: process.env.AXONFLOW_API_KEY });
+```
+
+## Proxy Mode (executeQuery)
+
+Proxy Mode routes all requests through AxonFlow's `/api/request` endpoint, providing a simpler integration pattern with automatic policy enforcement:
+
+### Basic Query Execution
+
+```typescript
+import { AxonFlow, PolicyViolationError } from '@axonflow/sdk';
+
+const axonflow = new AxonFlow({
+  licenseKey: process.env.AXONFLOW_LICENSE_KEY
+});
+
+// Execute a chat query with policy enforcement
+const response = await axonflow.executeQuery({
+  userToken: 'user-123',
+  query: 'Explain quantum computing in simple terms',
+  requestType: 'chat',
+  context: {
+    provider: 'openai',
+    model: 'gpt-4'
+  }
+});
+
+if (response.success) {
+  console.log('Response:', response.data);
+  console.log('Policies evaluated:', response.policyInfo?.policiesEvaluated);
+}
+```
+
+### Handling Policy Violations
+
+```typescript
+try {
+  await axonflow.executeQuery({
+    userToken: 'user-123',
+    query: 'Process this SSN: 123-45-6789',
+    requestType: 'chat'
+  });
+} catch (error) {
+  if (error instanceof PolicyViolationError) {
+    console.log('Request blocked:', error.blockReason);
+    console.log('Violating policies:', error.policies);
+  }
+}
+```
+
+### SQL Query Governance
+
+```typescript
+// SQL queries get additional injection detection
+const sqlResponse = await axonflow.executeQuery({
+  userToken: 'analyst-user',
+  query: 'SELECT name, email FROM customers WHERE status = active LIMIT 100',
+  requestType: 'sql'
+});
+```
+
+### Health Check
+
+```typescript
+// Check if AxonFlow agent is healthy
+const health = await axonflow.healthCheck();
+
+if (health.status === 'healthy') {
+  console.log('Agent version:', health.version);
+  console.log('Uptime:', health.uptime);
+} else {
+  console.warn('Agent status:', health.status);
+}
+```
+
+### Request Types
+
+| Request Type | Description |
+|--------------|-------------|
+| `chat` | General chat/LLM queries |
+| `sql` | SQL queries (with injection detection) |
+| `mcp-query` | MCP connector queries |
+| `multi-agent-plan` | Generate multi-agent plans |
+| `execute-plan` | Execute a generated plan |
+
+## Gateway Mode (Direct LLM Calls)
+
+Gateway Mode is for advanced users who want to make direct LLM calls while still getting policy enforcement:
+
+```typescript
+// Step 1: Pre-check policies
+const ctx = await axonflow.getPolicyApprovedContext({
+  userToken: 'user-jwt',
+  query: 'Analyze customer data',
+  dataSources: ['postgres']
+});
+
+if (!ctx.approved) {
+  throw new Error(`Blocked: ${ctx.blockReason}`);
+}
+
+// Step 2: Make direct LLM call with approved data
+const llmResponse = await openai.chat.completions.create({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: JSON.stringify(ctx.approvedData) }]
+});
+
+// Step 3: Audit the call
+await axonflow.auditLLMCall({
+  contextId: ctx.contextId,
+  responseSummary: llmResponse.choices[0].message.content.substring(0, 100),
+  provider: 'openai',
+  model: 'gpt-4',
+  tokenUsage: {
+    promptTokens: llmResponse.usage.prompt_tokens,
+    completionTokens: llmResponse.usage.completion_tokens,
+    totalTokens: llmResponse.usage.total_tokens
+  },
+  latencyMs: 250
+});
+```
+
 ## React Example
 
 ```tsx
 import { AxonFlow } from '@axonflow/sdk';
 import { useState } from 'react';
 
-const axonflow = new AxonFlow({ apiKey: 'your-key' });
+const axonflow = new AxonFlow({
+  licenseKey: process.env.REACT_APP_AXONFLOW_LICENSE_KEY
+});
 
 function ChatComponent() {
   const [response, setResponse] = useState('');
@@ -88,7 +269,9 @@ import { AxonFlow } from '@axonflow/sdk';
 import OpenAI from 'openai';
 
 const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-const axonflow = new AxonFlow({ apiKey: process.env.AXONFLOW_API_KEY });
+const axonflow = new AxonFlow({
+  licenseKey: process.env.AXONFLOW_LICENSE_KEY
+});
 
 export default async function handler(req, res) {
   const { prompt } = req.body;
@@ -144,7 +327,7 @@ For customers running within AWS VPC, use the private endpoint for sub-10ms late
 ```typescript
 const axonflow = new AxonFlow({
   apiKey: 'your-client-id',
-  endpoint: 'https://10.0.2.67:8443',  // VPC private endpoint (EU)
+  endpoint: 'https://vpc-private-endpoint.getaxonflow.com:8443',  // VPC private endpoint
   tenant: 'your-client-id',
   mode: 'production'
 });
@@ -286,6 +469,97 @@ if (resp.success) {
 }
 ```
 
+### Production Connectors (November 2025)
+
+AxonFlow now supports **7 production-ready connectors**:
+
+#### Salesforce CRM Connector
+
+Query Salesforce data using SOQL:
+
+```typescript
+// Query Salesforce contacts
+const contacts = await axonflow.queryConnector(
+  'salesforce-crm',
+  'Find all contacts for account Acme Corp',
+  {
+    soql: "SELECT Id, Name, Email, Phone FROM Contact WHERE AccountId = '001xx000003DHP0'"
+  }
+);
+
+console.log(`Found ${contacts.data.length} contacts`);
+```
+
+**Authentication:** OAuth 2.0 password grant (configured in AxonFlow dashboard)
+
+#### Snowflake Data Warehouse Connector
+
+Execute analytics queries on Snowflake:
+
+```typescript
+// Query Snowflake for sales analytics
+const analytics = await axonflow.queryConnector(
+  'snowflake-warehouse',
+  'Get monthly revenue for last 12 months',
+  {
+    sql: `SELECT DATE_TRUNC('month', order_date) as month,
+          COUNT(*) as orders,
+          SUM(amount) as revenue
+          FROM orders
+          WHERE order_date >= DATEADD(month, -12, CURRENT_DATE())
+          GROUP BY month
+          ORDER BY month`
+  }
+);
+
+console.log('Revenue data:', analytics.data);
+```
+
+**Authentication:** Key-pair JWT authentication (configured in AxonFlow dashboard)
+
+#### Slack Connector
+
+Send notifications and alerts to Slack channels:
+
+```typescript
+// Send Slack notification
+const result = await axonflow.queryConnector(
+  'slack-workspace',
+  'Send deployment notification to #engineering channel',
+  {
+    channel: '#engineering',
+    text: '🚀 Deployment complete! All systems operational.',
+    blocks: [
+      {
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: '*Deployment Status*\n✅ All systems operational'
+        }
+      }
+    ]
+  }
+);
+
+console.log('Message sent:', result.success);
+```
+
+**Authentication:** OAuth 2.0 bot token (configured in AxonFlow dashboard)
+
+#### Available Connectors
+
+| Connector | Type | Use Case |
+|-----------|------|----------|
+| PostgreSQL | Database | Relational data access |
+| Redis | Cache | Distributed rate limiting |
+| Slack | Communication | Team notifications |
+| Salesforce | CRM | Customer data, SOQL queries |
+| Snowflake | Data Warehouse | Analytics, reporting |
+| Amadeus GDS | Travel | Flight/hotel booking |
+| Cassandra | NoSQL | Distributed database |
+
+For complete connector documentation, see [https://docs.getaxonflow.com/mcp](https://docs.getaxonflow.com/mcp)
+
 ## Multi-Agent Planning (MAP)
 
 Generate and execute complex multi-step plans using AI agent orchestration:
@@ -351,9 +625,9 @@ if (status.status === 'running') {
 import { AxonFlow } from '@axonflow/sdk';
 
 async function planTrip() {
-  // Initialize client
+  // Initialize client with license key
   const axonflow = new AxonFlow({
-    apiKey: process.env.AXONFLOW_API_KEY,
+    licenseKey: process.env.AXONFLOW_LICENSE_KEY,
     debug: true
   });
 
@@ -381,6 +655,36 @@ async function planTrip() {
 planTrip().catch(console.error);
 ```
 
+## Migration Guide
+
+### Migrating from API Key to License Key
+
+If you're currently using `apiKey` authentication, migrate to license-based authentication:
+
+**Before:**
+```typescript
+const axonflow = new AxonFlow({
+  apiKey: process.env.AXONFLOW_API_KEY
+});
+```
+
+**After:**
+```typescript
+const axonflow = new AxonFlow({
+  licenseKey: process.env.AXONFLOW_LICENSE_KEY
+});
+```
+
+**How to get a license key:**
+1. Contact AxonFlow support at [dev@getaxonflow.com](mailto:dev@getaxonflow.com)
+2. License keys are provided as part of your AxonFlow subscription
+3. Store keys securely in environment variables or secrets management systems
+
+**Backward Compatibility:**
+- The SDK maintains full backward compatibility with `apiKey`
+- No breaking changes - existing code continues to work
+- You can migrate at your own pace
+
 ## License
 
 MIT

package/dist/cjs/client.d.ts

@@ -1,4 +1,4 @@
-import { AxonFlowConfig, ConnectorMetadata, ConnectorInstallRequest, ConnectorResponse, PlanResponse, PlanExecutionResponse, PreCheckRequest, PolicyApprovalResult, TokenUsage, AuditResult } from './types';
+import { AxonFlowConfig, ConnectorMetadata, ConnectorInstallRequest, ConnectorResponse, PlanResponse, PlanExecutionResponse, PolicyApprovalResult, PolicyApprovalOptions, AuditResult, AuditOptions, ExecuteQueryOptions, ExecuteQueryResponse, HealthStatus } from './types';
 /**
  * Main AxonFlow client for invisible AI governance
  */
@@ -32,6 +32,47 @@ export declare class AxonFlow {
      * Create a sandbox client for testing
      */
     static sandbox(apiKey?: string): AxonFlow;
+    /**
+     * Check if AxonFlow Agent is healthy and available.
+     *
+     * @returns HealthStatus object with agent health information
+     *
+     * @example
+     * ```typescript
+     * const health = await axonflow.healthCheck();
+     * if (health.status === 'healthy') {
+     *   console.log('Agent is healthy');
+     * }
+     * ```
+     */
+    healthCheck(): Promise<HealthStatus>;
+    /**
+     * Execute a query through AxonFlow with policy enforcement (Proxy Mode).
+     *
+     * This is the primary method for Proxy Mode, where AxonFlow handles policy
+     * checking and optionally routes requests to LLM providers.
+     *
+     * @param options - Query execution options
+     * @returns ExecuteQueryResponse with results or error information
+     * @throws PolicyViolationError if request is blocked by policy
+     * @throws AuthenticationError if credentials are invalid
+     * @throws APIError for other API errors
+     *
+     * @example
+     * ```typescript
+     * const response = await axonflow.executeQuery({
+     *   userToken: 'user-123',
+     *   query: 'Explain quantum computing',
+     *   requestType: 'chat',
+     *   context: { provider: 'openai', model: 'gpt-4' }
+     * });
+     *
+     * if (response.success) {
+     *   console.log('Response:', response.data);
+     * }
+     * ```
+     */
+    executeQuery(options: ExecuteQueryOptions): Promise<ExecuteQueryResponse>;
     /**
      * List all available MCP connectors from the marketplace
      */
@@ -46,66 +87,90 @@ export declare class AxonFlow {
     queryConnector(connectorName: string, query: string, params?: any): Promise<ConnectorResponse>;
     /**
      * Generate a multi-agent execution plan from a natural language query
+     * @param query - Natural language query describing the task
+     * @param domain - Optional domain hint (travel, healthcare, etc.)
+     * @param userToken - Optional user token for authentication (defaults to tenant/client_id)
      */
-    generatePlan(query: string, domain?: string): Promise<PlanResponse>;
+    generatePlan(query: string, domain?: string, userToken?: string): Promise<PlanResponse>;
     /**
      * Execute a previously generated multi-agent plan
+     * @param planId - ID of the plan to execute
+     * @param userToken - Optional user token for authentication (defaults to tenant/client_id)
      */
-    executePlan(planId: string): Promise<PlanExecutionResponse>;
+    executePlan(planId: string, userToken?: string): Promise<PlanExecutionResponse>;
     /**
      * Get the status of a running or completed plan
      */
     getPlanStatus(planId: string): Promise<PlanExecutionResponse>;
     /**
-     * Perform policy pre-check before making LLM call
-     *
-     * This is the first step in Gateway Mode. Call this before making your
-     * LLM call to ensure policy compliance.
+     * Gateway Mode: Pre-check policy approval before making a direct LLM call.
+     * Alias for getPolicyApprovedContext() for simpler API.
+     */
+    preCheck(options: PolicyApprovalOptions): Promise<PolicyApprovalResult>;
+    /**
+     * Gateway Mode: Get policy-approved context before making a direct LLM call.
      *
-     * @param request Pre-check request containing user token, query, and optional data sources
-     * @returns PolicyApprovalResult with context ID and approved data (if any)
+     * Use this when you want to:
+     * - Make direct LLM calls (not through AxonFlow proxy)
+     * - Have full control over your LLM provider/model selection
+     * - Minimize latency by calling LLM directly
      *
      * @example
-     * const result = await axonflow.getPolicyApprovedContext({
-     *   userToken: 'user-jwt-token',
-     *   dataSources: ['postgres', 'salesforce'],
-     *   query: 'Find all patients with recent lab results'
+     * ```typescript
+     * const ctx = await axonflow.getPolicyApprovedContext({
+     *   userToken: 'user-jwt',
+     *   query: 'Analyze this customer data',
+     *   dataSources: ['postgres']
      * });
      *
-     * if (!result.approved) {
-     *   throw new Error(`Request blocked: ${result.blockReason}`);
+     * if (!ctx.approved) {
+     *   throw new Error(`Blocked: ${ctx.blockReason}`);
      * }
      *
-     * // Use result.approvedData to build your LLM prompt
-     * const prompt = buildPrompt(result.approvedData);
+     * // Make direct LLM call with approved data
+     * const response = await openai.chat.completions.create({
+     *   model: 'gpt-4',
+     *   messages: [{ role: 'user', content: JSON.stringify(ctx.approvedData) }]
+     * });
+     *
+     * // Audit the call
+     * await axonflow.auditLLMCall({
+     *   contextId: ctx.contextId,
+     *   responseSummary: response.choices[0].message.content.substring(0, 100),
+     *   provider: 'openai',
+     *   model: 'gpt-4',
+     *   tokenUsage: {
+     *     promptTokens: response.usage.prompt_tokens,
+     *     completionTokens: response.usage.completion_tokens,
+     *     totalTokens: response.usage.total_tokens
+     *   },
+     *   latencyMs: 250
+     * });
+     * ```
      */
-    getPolicyApprovedContext(request: PreCheckRequest): Promise<PolicyApprovalResult>;
+    getPolicyApprovedContext(options: PolicyApprovalOptions): Promise<PolicyApprovalResult>;
     /**
-     * Report LLM call details for audit logging
+     * Gateway Mode: Audit an LLM call after completion.
      *
-     * This is the second step in Gateway Mode. Call this after making your
-     * LLM call to record it in the audit trail.
-     *
-     * @param contextId Context ID from getPolicyApprovedContext()
-     * @param responseSummary Brief summary of the LLM response (not full response)
-     * @param provider LLM provider name
-     * @param model Model name
-     * @param tokenUsage Token counts from LLM response
-     * @param latencyMs Time taken for LLM call in milliseconds
-     * @param metadata Optional additional metadata
-     * @returns AuditResult confirming the audit was recorded
+     * Call this after making a direct LLM call to log the audit trail.
+     * This is required for compliance and monitoring.
      *
      * @example
-     * const result = await axonflow.auditLLMCall(
-     *   ctx.contextId,
-     *   'Found 5 patients with recent lab results',
-     *   'openai',
-     *   'gpt-4',
-     *   { promptTokens: 100, completionTokens: 50, totalTokens: 150 },
-     *   250,
-     *   { sessionId: 'session-123' }
-     * );
-     */
-    auditLLMCall(contextId: string, responseSummary: string, provider: string, model: string, tokenUsage: TokenUsage, latencyMs: number, metadata?: Record<string, any>): Promise<AuditResult>;
+     * ```typescript
+     * await axonflow.auditLLMCall({
+     *   contextId: ctx.contextId,
+     *   responseSummary: 'Generated report with 5 items',
+     *   provider: 'openai',
+     *   model: 'gpt-4',
+     *   tokenUsage: {
+     *     promptTokens: 100,
+     *     completionTokens: 50,
+     *     totalTokens: 150
+     *   },
+     *   latencyMs: 250
+     * });
+     * ```
+     */
+    auditLLMCall(options: AuditOptions): Promise<AuditResult>;
 }
 //# sourceMappingURL=client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAId,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,eAAe,EACf,oBAAoB,EACpB,UAAU,EACV,WAAW,EACZ,MAAM,SAAS,CAAC;AAMjB;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAyB;gBAEjC,MAAM,EAAE,cAAc;IAwBlC;;;;OAIG;IACG,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAqD5D;;OAEG;YACW,cAAc;IAiB5B;;OAEG;YACW,aAAa;IAuD3B;;OAEG;YACW,QAAQ;IAYtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAMvB;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,GAAE,MAAmB,GAAG,QAAQ;IASrD;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAqBpD;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBvE;;OAEG;IACG,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA0CpG;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IA6CzE;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAyCjE;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAuDnE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,wBAAwB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA8DvF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC7B,OAAO,CAAC,WAAW,CAAC;CA4DxB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAId,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACb,MAAM,SAAS,CAAC;AAOjB;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAUZ;IACF,OAAO,CAAC,YAAY,CAAyB;gBAEjC,MAAM,EAAE,cAAc;IAqDlC;;;;OAIG;IACG,OAAO,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAuD5D;;OAEG;YACW,cAAc;IAiB5B;;OAEG;YACW,aAAa;IAyE3B;;OAEG;YACW,QAAQ;IAYtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,GAAE,MAAmB,GAAG,QAAQ;IAarD;;;;;;;;;;;;OAYG;IACG,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC;IA0C1C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAwG/E;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAqBpD;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCvE;;OAEG;IACG,cAAc,CAClB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,GAAG,GACX,OAAO,CAAC,iBAAiB,CAAC;IAkD7B;;;;;OAKG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAqD7F;;;;OAIG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAiDrF;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA+BnE;;;OAGG;IACG,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAI7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,wBAAwB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAkF7F;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;CAqEhE"}