integrate-sdk 0.2.4 → 0.3.2

package/README.md

@@ -12,8 +12,9 @@ A type-safe TypeScript SDK for connecting to the Integrate MCP (Model Context Pr
 - 🔌 **Plugin-Based Architecture** - Enable only the integrations you need
 - 🔒 **Fully Typed API** - Type-safe methods with autocomplete (e.g., `client.github.createIssue()`)
 - 💡 **IntelliSense Support** - Full TypeScript support with parameter hints
-- 🌊 **Real-time Communication** - HTTP streaming with NDJSON
-- 🔐 **OAuth Ready** - Configure OAuth credentials for each provider
+- ⚡ **Automatic Connection Management** - Lazy connection, auto-cleanup, singleton pattern
+- 🔐 **Complete OAuth Flow** - Built-in OAuth 2.0 with PKCE (popup/redirect modes)
+- 🌍 **Universal** - Works in browser and Node.js environments
 - 🛠️ **Extensible** - Configure plugins for any server-supported integration
 - 📦 **Zero Dependencies** - Lightweight implementation
 
@@ -27,340 +28,244 @@ bun add integrate-sdk
 
 ## Quick Start
 
+### Server-Side Setup
+
+First, create your server configuration with OAuth secrets:
+
 ```typescript
-import { createMCPClient, githubPlugin } from "integrate-sdk";
+// lib/integrate-server.ts (server-side only!)
+import { createMCPServer, githubPlugin, gmailPlugin } from 'integrate-sdk/server';
 
-// Create a client with plugins
-const client = createMCPClient({
+export const { client: serverClient, handlers } = createMCPServer({
   plugins: [
     githubPlugin({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-      scopes: ["repo", "user"],
+      clientId: process.env.GITHUB_CLIENT_ID,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET,
+      scopes: ['repo', 'user'],
+    }),
+    gmailPlugin({
+      clientId: process.env.GMAIL_CLIENT_ID,
+      clientSecret: process.env.GMAIL_CLIENT_SECRET,
+      scopes: ['gmail.readonly'],
     }),
   ],
 });
-
-// Connect to the server
-await client.connect();
-
-// Call GitHub methods with full type safety
-const result = await client.github.createIssue({
-  owner: "owner",
-  repo: "repo",
-  title: "Bug report",
-  body: "Description of the bug",
-});
-
-console.log("Issue created:", result);
-
-// Call server-level tools with typed methods
-const tools = await client.server.listToolsByIntegration({
-  integration: "github",
-});
-
-// Disconnect when done
-await client.disconnect();
 ```
 
-**Need help?** Check out the [complete documentation](https://integrate.dev) for detailed guides, examples, and API reference.
-
-## Why Use Integrate SDK?
-
-### Typed Plugin Methods
-
-Instead of generic tool calls, use typed methods with full autocomplete:
+Create OAuth route (handles authorization automatically):
 
 ```typescript
-// ✅ New: Typed methods with autocomplete
-await client.github.createIssue({ owner: "user", repo: "project", title: "Bug" });
-await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
+// app/api/integrate/oauth/[action]/route.ts
+export * from 'integrate-sdk/oauth';
 ```
 
-### Benefits
-
-- **Type Safety**: Parameters are validated at compile time
-- **Autocomplete**: Your IDE suggests available methods and parameters
-- **Documentation**: Inline JSDoc comments for every method
-- **Refactoring**: Rename methods safely across your codebase
-
-### Three Ways to Call Tools
+Use the server client in API routes or server components:
 
 ```typescript
-// 1. Typed plugin methods (recommended for built-in plugins like GitHub/Gmail)
-await client.github.createIssue({ owner: "user", repo: "project", title: "Bug" });
-await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
-
-// 2. Typed server methods (for server-level tools)
-await client.server.listToolsByIntegration({ integration: "github" });
+// app/api/repos/route.ts
+import { serverClient } from '@/lib/integrate-server';
 
-// 3. Direct tool calls (for other server-supported integrations)
-await client._callToolByName("slack_send_message", { channel: "#general", text: "Hello" });
+export async function GET() {
+  // Automatically connects on first call - no manual setup needed!
+  const repos = await serverClient.github.listOwnRepos({ per_page: 10 });
+  return Response.json({ repos });
+}
 ```
 
-## OAuth Authorization
-
-The SDK implements OAuth 2.0 Authorization Code Flow with PKCE for secure third-party service authorization. Users must authorize your application to access their GitHub, Gmail, or other accounts.
-
-### How It Works
+### Client-Side Setup
 
-1. **Your App**: Creates client with OAuth configuration
-2. **SDK**: Initiates OAuth flow (popup or redirect)
-3. **User**: Authorizes permissions on provider's website
-4. **Provider**: Redirects back with authorization code
-5. **Your Server**: Exchanges code for tokens and stores them
-6. **SDK**: Includes session token in all API requests
-7. **Your Server**: Uses stored OAuth tokens for API calls
-
-### Quick Start
+Use in your client components (no secrets needed):
 
 ```typescript
-import { createMCPClient, githubPlugin } from "integrate-sdk";
+'use client';
+import { createMCPClient, githubPlugin } from 'integrate-sdk';
 
-// Create client with OAuth flow configuration
 const client = createMCPClient({
   plugins: [
     githubPlugin({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-      scopes: ["repo", "user"],
-      redirectUri: "http://localhost:3000/oauth/callback",
+      scopes: ['repo', 'user'],
+      // No clientId or clientSecret needed!
     }),
   ],
-  oauthFlow: {
-    mode: 'popup', // or 'redirect'
-    popupOptions: { width: 600, height: 700 },
-  },
+  oauthFlow: { mode: 'popup' },
 });
 
-// Check if authorized
-const isAuthorized = await client.isAuthorized('github');
+// Authorize user (opens popup)
+await client.authorize('github');
 
-if (!isAuthorized) {
-  // Initiate OAuth flow - opens popup or redirects
-  await client.authorize('github');
-}
+// Use the client - automatically connects!
+const result = await client.github.createIssue({
+  owner: 'owner',
+  repo: 'repo',
+  title: 'Bug report',
+  body: 'Description of the bug',
+});
 
-// Now you can use GitHub tools
-const repos = await client.github.listOwnRepos({});
+console.log('Issue created:', result);
 ```
 
-### Popup Flow (Recommended for SPAs)
+**That's it!** The SDK automatically:
+- ✅ Connects on first method call (no manual `connect()` needed)
+- ✅ Cleans up on exit (no manual `disconnect()` needed)
+- ✅ Manages OAuth tokens securely through your API routes
+- ✅ Provides full type safety with autocomplete
+
+### Connection Management
 
-Best for single-page applications - authorization happens in a popup without leaving your app.
+The SDK automatically manages connections for you - no manual `connect()` or `disconnect()` calls needed!
+
+**Features:**
+- **Lazy Connection**: Automatically connects on first method call
+- **Auto-Cleanup**: Cleans up on process exit
+- **Singleton Pattern**: Reuses connections efficiently (configurable)
 
 ```typescript
+// ✅ Default behavior - automatic connection
 const client = createMCPClient({
-  plugins: [githubPlugin({ ... })],
-  oauthFlow: { mode: 'popup' },
+  plugins: [
+    githubPlugin({
+      scopes: ['repo', 'user'],
+    }),
+  ],
 });
 
-// This opens a popup for authorization
+// Use immediately - no connect() needed!
 await client.authorize('github');
+await client.github.listRepos({ username: 'octocat' });
 
-// After user approves, continues automatically
-const repos = await client.github.listOwnRepos({});
-```
+// ✅ Want manual control? Use manual mode
+const manualClient = createMCPClient({
+  plugins: [githubPlugin({ scopes: ['repo'] })],
+  connectionMode: 'manual',
+  singleton: false,
+});
 
-**Callback Page**: Create `/oauth/callback.html`:
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <title>OAuth Callback</title>
-  <script type="module">
-    import { sendCallbackToOpener } from 'integrate-sdk';
-    
-    const params = new URLSearchParams(window.location.search);
-    sendCallbackToOpener({
-      code: params.get('code'),
-      state: params.get('state'),
-      error: params.get('error')
-    });
-  </script>
-</head>
-<body>
-  <p>Authorization successful! Closing...</p>
-</body>
-</html>
+await manualClient.connect();
+await manualClient.authorize('github');
+await manualClient.github.listRepos({ username: 'octocat' });
+await manualClient.disconnect();
 ```
 
-### Redirect Flow (Traditional Web Apps)
+**Need help?** Check out the [complete documentation](https://integrate.dev) for detailed guides, examples, and API reference.
 
-Best for traditional server-rendered applications.
+## Browser & Server Support
 
-```typescript
-// Main page
-const client = createMCPClient({
-  plugins: [githubPlugin({ ... })],
-  oauthFlow: { mode: 'redirect' },
-});
+The SDK works in both environments:
 
-if (!await client.isAuthorized('github')) {
-  await client.authorize('github'); // Redirects to GitHub
-}
+- **Browser**: Use `createMCPClient()` from `'integrate-sdk'` - handles OAuth UI (popup/redirect)
+- **Server**: Use `createMCPServer()` from `'integrate-sdk/server'` - includes OAuth secrets for API routes
 
-// Callback page (e.g., /oauth/callback)
-const params = new URLSearchParams(window.location.search);
-await client.handleOAuthCallback({
-  code: params.get('code')!,
-  state: params.get('state')!
-});
+See [Quick Start](#quick-start) above for complete examples.
 
-// Save session token for future use
-const sessionToken = client.getSessionToken();
-localStorage.setItem('session_token', sessionToken);
+## Why Use Integrate SDK?
+
+### Typed Plugin Methods
 
-// Redirect back to main app
+Instead of generic tool calls, use typed methods with full autocomplete:
+
+```typescript
+// ✅ New: Typed methods with autocomplete
+await client.github.createIssue({ owner: "user", repo: "project", title: "Bug" });
+await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
 ```
 
-### Session Token Management
+### Benefits
 
-Store and restore sessions to avoid re-authorization:
+- **Type Safety**: Parameters are validated at compile time
+- **Autocomplete**: Your IDE suggests available methods and parameters
+- **Documentation**: Inline JSDoc comments for every method
+- **Refactoring**: Rename methods safely across your codebase
+
+### Three Ways to Call Tools
 
 ```typescript
-// Restore previous session
-const client = createMCPClient({
-  plugins: [githubPlugin({ ... })],
-  sessionToken: localStorage.getItem('session_token'),
-});
+// 1. Typed plugin methods (recommended for built-in plugins like GitHub/Gmail)
+await client.github.createIssue({ owner: "user", repo: "project", title: "Bug" });
+await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello" });
 
-// Check if session is still valid
-if (!await client.isAuthorized('github')) {
-  await client.authorize('github');
-}
+// 2. Typed server methods (for server-level tools)
+await client.server.listToolsByIntegration({ integration: "github" });
 
-// Store token after new authorization
-const token = client.getSessionToken();
-localStorage.setItem('session_token', token);
+// 3. Direct tool calls (for other server-supported integrations)
+await client._callToolByName("slack_send_message", { channel: "#general", text: "Hello" });
 ```
 
-### Multiple Providers
+## OAuth Authorization
 
-Authorize multiple services independently:
+The SDK implements OAuth 2.0 Authorization Code Flow with PKCE for secure authorization.
 
-```typescript
-const client = createMCPClient({
-  plugins: [
-    githubPlugin({ ... }),
-    gmailPlugin({ ... }),
-  ],
-  oauthFlow: { mode: 'popup' },
-});
-
-// Get list of all authorized providers
-const authorized = await client.authorizedProviders();
-console.log('Authorized:', authorized); // ['github', 'gmail']
+**Key Features:**
+- ✅ Popup or redirect flow modes
+- ✅ Session token management
+- ✅ Multiple provider support
+- ✅ PKCE security
 
-// Or check and authorize each provider individually
+**Basic Usage:**
+```typescript
+// Check authorization
 if (!await client.isAuthorized('github')) {
-  await client.authorize('github');
-}
-
-if (!await client.isAuthorized('gmail')) {
-  await client.authorize('gmail');
+  await client.authorize('github'); // Opens popup or redirects
 }
 
-// Use both services
+// Use authorized client
 const repos = await client.github.listOwnRepos({});
-const messages = await client.gmail.listMessages({});
 ```
 
-### Server Requirements
-
-Your MCP server must implement these OAuth endpoints:
+For complete OAuth setup including:
+- Popup vs redirect flows
+- Session token management
+- Multiple providers
+- Callback page setup
 
-**GET `/oauth/authorize`** - Returns authorization URL
-**POST `/oauth/callback`** - Exchanges code for tokens, returns session token
-**GET `/oauth/status`** - Checks authorization status
-
-All tool endpoints must accept `X-Session-Token` header and use stored OAuth tokens for API calls.
-
-[→ View complete OAuth flow implementation guide](/docs/guides/oauth-flow.md)
+See the [`/examples`](/examples) directory or [OAuth documentation](https://integrate.dev/docs/guides/oauth-flow).
 
 ## Built-in Plugins
 
 ### GitHub Plugin
 
-Access GitHub repositories, issues, pull requests, and more.
+Access GitHub repositories, issues, pull requests, and more with type-safe methods.
 
 ```typescript
-const client = createMCPClient({
-  plugins: [
-    githubPlugin({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-      scopes: ["repo", "user"],
-    }),
-  ],
-});
-
-await client.connect();
-
-// Use typed methods
-await client.github.getRepo({ owner: "facebook", repo: "react" });
-await client.github.createIssue({ owner: "user", repo: "repo", title: "Bug" });
-await client.github.listPullRequests({ owner: "user", repo: "repo", state: "open" });
+// Available methods
+await client.github.getRepo({ owner: 'facebook', repo: 'react' });
+await client.github.createIssue({ owner: 'user', repo: 'repo', title: 'Bug' });
+await client.github.listPullRequests({ owner: 'user', repo: 'repo', state: 'open' });
+await client.github.listOwnRepos({});
 ```
 
-[→ View GitHub plugin documentation](https://integrate.dev/docs/plugins/github)
+[→ GitHub plugin documentation](https://integrate.dev/docs/plugins/github)
 
 ### Gmail Plugin
 
-Send emails, manage labels, and search messages.
+Send emails, manage labels, and search messages with type-safe methods.
 
 ```typescript
-const client = createMCPClient({
-  plugins: [
-    gmailPlugin({
-      clientId: process.env.GMAIL_CLIENT_ID!,
-      clientSecret: process.env.GMAIL_CLIENT_SECRET!,
-    }),
-  ],
-});
-
-await client.connect();
-
-// Use typed methods
-await client.gmail.sendEmail({ to: "user@example.com", subject: "Hello", body: "Hi!" });
-await client.gmail.listEmails({ maxResults: 10, q: "is:unread" });
-await client.gmail.searchEmails({ query: "from:notifications@github.com" });
+// Available methods
+await client.gmail.sendEmail({ to: 'user@example.com', subject: 'Hello', body: 'Hi!' });
+await client.gmail.listEmails({ maxResults: 10, q: 'is:unread' });
+await client.gmail.searchEmails({ query: 'from:notifications@github.com' });
 ```
 
-[→ View Gmail plugin documentation](https://integrate.dev/docs/plugins/gmail)
+[→ Gmail plugin documentation](https://integrate.dev/docs/plugins/gmail)
 
-### Configure Additional Integrations
+### Additional Integrations
 
-The server may support additional integrations beyond GitHub and Gmail. You can configure OAuth and enable these tools using `genericOAuthPlugin`:
+Use `genericOAuthPlugin` to configure any server-supported integration:
 
 ```typescript
-import { genericOAuthPlugin } from "integrate-sdk";
+import { genericOAuthPlugin } from 'integrate-sdk/server';
 
-// Configure a plugin for any server-supported integration
 const slackPlugin = genericOAuthPlugin({
-  id: "slack",
-  provider: "slack",
-  clientId: process.env.SLACK_CLIENT_ID!,
-  clientSecret: process.env.SLACK_CLIENT_SECRET!,
-  scopes: ["chat:write", "channels:read"],
-  tools: ["slack_send_message", "slack_list_channels"], // Must exist on server
-});
-
-const client = createMCPClient({
-  plugins: [slackPlugin],
-});
-
-await client.connect();
-
-// Use _callToolByName to call the tools
-await client._callToolByName("slack_send_message", { 
-  channel: "#general", 
-  text: "Hello!" 
+  id: 'slack',
+  provider: 'slack',
+  clientId: process.env.SLACK_CLIENT_ID,
+  clientSecret: process.env.SLACK_CLIENT_SECRET,
+  scopes: ['chat:write', 'channels:read'],
+  tools: ['slack_send_message', 'slack_list_channels'],
 });
 ```
 
-**Note**: Plugins configure access to server-provided tools - they don't create new tools. All tool implementations must exist on the Integrate MCP server.
+See [`/examples`](/examples) for complete setup patterns.
 
 ## Vercel AI SDK Integration
 
@@ -390,6 +295,7 @@ const result = await generateText({
 For detailed guides, API reference, and examples, visit the [complete documentation](https://integrate.dev):
 
 - **[Getting Started](https://integrate.dev/docs/getting-started/installation)** - Installation and quick start
+- **[OAuth Flow](https://integrate.dev/docs/guides/oauth-flow)** - OAuth 2.0 authorization guide
 - **[Plugins](https://integrate.dev/docs/plugins)** - Built-in plugins and configuration
 - **[Vercel AI SDK](https://integrate.dev/docs/integrations/vercel-ai)** - AI model integration
 - **[Advanced Usage](https://integrate.dev/docs/guides/advanced-usage)** - Error handling, retries, and more

package/dist/index.d.ts

@@ -1,27 +1,20 @@
 /**
- * Integrate SDK
- * Type-safe TypeScript SDK for MCP Client
+ * Integrate SDK - Main Entry Point
+ *
+ * Client-side SDK for MCP with plugin-based configuration
+ *
+ * @example
+ * ```typescript
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ *
+ * const client = createMCPClient({
+ *   plugins: [
+ *     githubPlugin({
+ *       scopes: ['repo', 'user'],
+ *     }),
+ *   ],
+ * });
+ * ```
  */
-export { MCPClient, createMCPClient, clearClientCache } from "./client.js";
-export type { ToolInvocationOptions } from "./client.js";
-export { OAuthManager } from "./oauth/manager.js";
-export { OAuthWindowManager, sendCallbackToOpener } from "./oauth/window-manager.js";
-export { generateCodeVerifier, generateCodeChallenge, generateState } from "./oauth/pkce.js";
-export type { OAuthFlowConfig, PopupOptions, AuthStatus, PendingAuth, AuthorizationUrlResponse, OAuthCallbackResponse, OAuthCallbackParams, } from "./oauth/types.js";
-export type { MCPClientConfig, ReauthContext, ReauthHandler } from "./config/types.js";
-export { IntegrateSDKError, AuthenticationError, AuthorizationError, TokenExpiredError, ConnectionError, ToolCallError, isAuthError, isTokenExpiredError, isAuthorizationError, parseServerError, } from "./errors.js";
-export type { MCPPlugin, OAuthConfig, ExtractPluginIds, ExtractPluginTools, } from "./plugins/types.js";
-export { githubPlugin } from "./plugins/github.js";
-export type { GitHubPluginConfig, GitHubTools, GitHubPluginClient } from "./plugins/github.js";
-export { gmailPlugin } from "./plugins/gmail.js";
-export type { GmailPluginConfig, GmailTools, GmailPluginClient } from "./plugins/gmail.js";
-export type { ServerPluginClient } from "./plugins/server-client.js";
-export { genericOAuthPlugin, createSimplePlugin, } from "./plugins/generic.js";
-export type { GenericOAuthPluginConfig } from "./plugins/generic.js";
-export { convertMCPToolToVercelAI, convertMCPToolsToVercelAI, getVercelAITools, } from "./integrations/vercel-ai.js";
-export type { VercelAITool } from "./integrations/vercel-ai.js";
-export type { JSONRPCRequest, JSONRPCResponse, JSONRPCSuccessResponse, JSONRPCErrorResponse, JSONRPCNotification, MCPTool, MCPToolsListResponse, MCPToolCallParams, MCPToolCallResponse, MCPInitializeParams, MCPInitializeResponse, } from "./protocol/messages.js";
-export { MCPMethod } from "./protocol/messages.js";
-export { HttpSessionTransport } from "./transport/http-session.js";
-export type { MessageHandler, HttpSessionTransportOptions, } from "./transport/http-session.js";
+export * from './src/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC3E,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC7F,YAAY,EACV,eAAe,EACf,YAAY,EACZ,UAAU,EACV,WAAW,EACX,wBAAwB,EACxB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvF,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE/F,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG3F,YAAY,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,OAAO,EACL,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,YAAY,EACV,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,OAAO,EACP,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EACV,cAAc,EACd,2BAA2B,GAC5B,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,cAAc,gBAAgB,CAAC"}