@lunch-money/developer-docs 2.11.0-preview.10

package/docs/rate-limiting.md

@@ -0,0 +1,335 @@
+# Rate Limiting
+
+The Lunch Money API implements rate limiting to ensure fair usage and prevent abuse of API resources. This guide explains how rate limiting works and how to monitor your rate limit status using response headers.
+
+
+## Overview
+
+Rate limiting is applied to all requests to the `/v1/` and `/v2/` endpoints and limits request from a single source to 100 requests per minute.
+
+If you exceed this limit, you will receive a `429 Too Many Requests` response.
+
+> [!NOTE] Rate Limit Scope
+> Rate limiting is applied per IP address. Requests from the same IP address share the same rate limit quotas.
+
+## Rate Limit Response
+
+When you exceed a rate limit, the API returns a `429 Too Many Requests` response:
+
+### HTTP Status Code
+
+```
+429 Too Many Requests
+```
+
+### Response Body
+
+The response body follows the standard v2 error format:
+
+```json
+{
+  "message": "Too Many Requests",
+  "errors": [
+    {
+      "errMsg": "Too many requests, please try again later."
+    }
+  ]
+}
+```
+
+### Response Headers
+
+The API includes rate limit information in response headers for all requests (both successful and rate-limited). You can inspect these headers to monitor your current rate limit status and determine when you can make additional requests.
+
+#### Standard Headers (RFC Draft 7)
+
+The API includes standard rate limit headers in all responses:
+
+- **`RateLimit-Limit`**: The maximum number of requests allowed per window
+- **`RateLimit-Remaining`**: The number of requests remaining in the current window
+- **`RateLimit-Reset`**: The time (in seconds since Unix epoch) when the rate limit window resets
+
+Example headers:
+```
+RateLimit-Limit: 100
+RateLimit-Remaining: 3
+RateLimit-Reset: 1704067200
+```
+
+#### Legacy Headers
+
+For backward compatibility, the API also includes legacy `X-RateLimit-*` headers:
+
+- **`X-RateLimit-Limit`**: The maximum number of requests allowed per window
+- **`X-RateLimit-Remaining`**: The number of requests remaining in the current window  
+- **`X-RateLimit-Reset`**: The time (in seconds since Unix epoch) when the rate limit window resets
+
+Example headers:
+```
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 3
+X-RateLimit-Reset: 1704067200
+```
+
+#### Retry-After Header
+
+When you receive a `429 Too Many Requests` response, the API includes a `Retry-After` header indicating how many seconds you should wait before retrying:
+
+```
+Retry-After: 45
+```
+
+This value represents the time until the rate limit window resets (rounded up to the nearest second).
+
+> [!TIP] Using Retry-After
+> Always respect the `Retry-After` header value when implementing retry logic. Waiting for the specified duration ensures you don't waste requests on premature retries.
+
+## Monitoring Rate Limits
+
+### Reading Rate Limit Headers
+
+You can monitor your rate limit status by inspecting the headers in every API response, even successful ones. This allows you to proactively slow down your request rate before hitting the limit.
+
+:::tabs
+@tab JavaScript/Node.js
+```javascript
+async function makeRequest(url, options) {
+  const response = await fetch(url, options);
+  
+  // Check rate limit status from headers
+  const remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');
+  const limit = parseInt(response.headers.get('X-RateLimit-Limit') || '0');
+  const resetTime = parseInt(response.headers.get('X-RateLimit-Reset') || '0');
+  
+  if (remaining < 5) {
+    console.warn(`Rate limit warning: ${remaining}/${limit} requests remaining`);
+    const waitTime = resetTime - Math.floor(Date.now() / 1000);
+    if (waitTime > 0) {
+      console.log(`Rate limit resets in ${waitTime} seconds`);
+    }
+  }
+  
+  if (response.status === 429) {
+    const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
+    console.error(`Rate limited! Retry after ${retryAfter} seconds`);
+    throw new Error(`Rate limited: retry after ${retryAfter}s`);
+  }
+  
+  return response;
+}
+```
+
+@tab Python
+```python
+import requests
+import time
+
+def make_request(url, headers):
+    response = requests.get(url, headers=headers)
+    
+    # Check rate limit status
+    remaining = int(response.headers.get('X-RateLimit-Remaining', 0))
+    limit = int(response.headers.get('X-RateLimit-Limit', 0))
+    reset_time = int(response.headers.get('X-RateLimit-Reset', 0))
+    
+    if remaining < 5:
+        print(f"Rate limit warning: {remaining}/{limit} requests remaining")
+        wait_time = reset_time - int(time.time())
+        if wait_time > 0:
+            print(f"Rate limit resets in {wait_time} seconds")
+    
+    if response.status_code == 429:
+        retry_after = int(response.headers.get('Retry-After', 60))
+        print(f"Rate limited! Retry after {retry_after} seconds")
+        raise Exception(f"Rate limited: retry after {retry_after}s")
+    
+    return response
+```
+
+@tab cURL
+```bash
+# Make a request and capture headers
+response=$(curl -s -D /tmp/headers.txt -o /tmp/body.txt -w "%{http_code}" \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  "https://api.lunchmoney.dev/v2/me")
+
+# Extract rate limit headers
+remaining=$(grep -i "^X-RateLimit-Remaining" /tmp/headers.txt | cut -d' ' -f2 | tr -d '\r')
+limit=$(grep -i "^X-RateLimit-Limit" /tmp/headers.txt | cut -d' ' -f2 | tr -d '\r')
+reset=$(grep -i "^X-RateLimit-Reset" /tmp/headers.txt | cut -d' ' -f2 | tr -d '\r')
+
+echo "Status: $response"
+echo "Rate Limit: $remaining/$limit remaining"
+echo "Resets at: $reset"
+
+# Check if rate limited
+if [ "$response" = "429" ]; then
+    retry_after=$(grep -i "^Retry-After" /tmp/headers.txt | cut -d' ' -f2 | tr -d '\r')
+    echo "Rate limited! Wait $retry_after seconds before retrying"
+fi
+```
+:::
+
+### Implementing Exponential Backoff
+
+When you receive a `429` response, implement exponential backoff with jitter to avoid overwhelming the API:
+
+```javascript
+async function makeRequestWithRetry(url, options, maxRetries = 3) {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    const response = await fetch(url, options);
+    
+    if (response.status !== 429) {
+      return response;
+    }
+    
+    // Get retry-after header or use exponential backoff
+    const retryAfter = parseInt(response.headers.get('Retry-After') || '0');
+    const waitTime = retryAfter > 0 
+      ? retryAfter * 1000  // Convert seconds to milliseconds
+      : Math.min(1000 * Math.pow(2, attempt) + Math.random() * 1000, 30000);
+    
+    console.log(`Rate limited. Waiting ${waitTime}ms before retry ${attempt + 1}/${maxRetries}`);
+    await new Promise(resolve => setTimeout(resolve, waitTime));
+  }
+  
+  throw new Error('Max retries exceeded due to rate limiting');
+}
+```
+
+## Best Practices
+
+### 1. Monitor Headers Proactively
+
+Don't wait for a `429` response. Check rate limit headers on every request and adjust your request rate accordingly:
+
+```javascript
+// Pseudo-code example
+if (remaining < threshold) {
+  const waitTime = (resetTime - currentTime) * 1000;
+  await sleep(waitTime);
+}
+```
+
+### 2. Implement Request Queuing
+
+For applications that need to make many requests, implement a queue system that respects rate limits:
+
+```javascript
+class RateLimitedQueue {
+  constructor() {
+    this.queue = [];
+    this.remaining = 100; // Start with max
+    this.resetTime = Date.now() + (15 * 60 * 1000);
+  }
+  
+  async enqueue(requestFn) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ requestFn, resolve, reject });
+      this.processQueue();
+    });
+  }
+  
+  async processQueue() {
+    if (this.queue.length === 0 || this.remaining <= 0) {
+      if (this.remaining <= 0 && this.resetTime > Date.now()) {
+        // Wait until reset
+        setTimeout(() => this.processQueue(), this.resetTime - Date.now());
+      }
+      return;
+    }
+    
+    const { requestFn, resolve, reject } = this.queue.shift();
+    try {
+      const response = await requestFn();
+      
+      // Update rate limit status from headers
+      this.remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');
+      this.resetTime = parseInt(response.headers.get('X-RateLimit-Reset') || '0') * 1000;
+      
+      resolve(response);
+      this.processQueue(); // Process next item
+    } catch (error) {
+      reject(error);
+    }
+  }
+}
+```
+
+### 3. Cache Responses When Possible
+
+Reduce the number of API calls by caching responses locally:
+
+```javascript
+const cache = new Map();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+async function getCachedRequest(url, options) {
+  const cacheKey = `${url}:${JSON.stringify(options)}`;
+  const cached = cache.get(cacheKey);
+  
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.data;
+  }
+  
+  const response = await fetch(url, options);
+  const data = await response.json();
+  
+  cache.set(cacheKey, {
+    data,
+    timestamp: Date.now()
+  });
+  
+  return data;
+}
+```
+
+### 4. Batch Operations When Available
+
+Use bulk endpoints when available to reduce the number of requests:
+
+:::tabs
+@tab Instead of multiple requests
+```javascript
+// ❌ Inefficient: 5 separate requests
+for (const category_id of categories_in_transactions) {
+  await fetch(`/v2/categories/{category_id}`, {
+    method: 'GET',
+  });
+}
+```
+
+@tab Use bulk endpoints
+```javascript
+// ✅ Efficient: Single request
+await fetch('/v2/categories', {
+  method: 'GET',
+});
+// Process response and then map ids to categories
+```
+:::
+
+### 5. Limit Crypto Refresh Polling
+
+Crypto refresh requests can be bursty if you poll too often. For `POST /v2/crypto/synced/{id}/refresh`:
+
+- Prefer event- or schedule-based refreshes over tight loops
+- Space refresh calls for the same synced connection to avoid unnecessary retries
+- Use `Retry-After` and remaining rate limit headers to back off quickly when approaching the limit
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: Rate limits resetting unexpectedly
+
+**Solution**: Rate limits are tracked per IP address. If you're behind a proxy or load balancer, multiple clients may share the same IP and exhaust the shared quota.
+
+
+## Need Help?
+
+If you're experiencing rate limiting issues that can't be resolved through the techniques described above:
+
+- Review your application's request patterns and implement caching where appropriate
+- Consider implementing request queuing to better manage your API usage
+- [Email our developer advocate](mailto:jp@lunchmoney.app) if you have a legitimate need for higher rate limits

package/docs/using-with-ai.md

@@ -0,0 +1,103 @@
+# Using the API with AI
+
+AI tools can connect to your Lunch Money data in two ways: through an MCP server that lets you ask natural-language questions in a chat interface, or through an AI coding assistant that helps you write scripts against the API. This page explains both approaches and how to handle your access token safely in each.
+
+> [!NOTE]
+> Lunch Money never shares your data with AI automatically. AI only gets access to your data when you choose to connect it.
+
+## Option 1: Connect an AI assistant via MCP
+
+MCP (Model Context Protocol) is a standard that lets AI assistants use external tools. A Lunch Money MCP server acts as a bridge between your AI chat app and the Lunch Money API, letting you ask questions like:
+
+- "How much did I spend on restaurants last month?"
+- "Show me my largest uncategorized transactions."
+- "Which categories are trending above normal this month?"
+
+The <a href="https://lunchmoney.app/developers#mcp-servers" target="_blank" rel="noopener noreferrer">Lunch Money developers page</a> lists community-built MCP servers. Pick one whose setup instructions and permission model you're comfortable with, and follow its documentation carefully. If you're not sure where to start, <a href="https://github.com/akutishevsky/lunchmoney-mcp#usage" target="_blank" rel="noopener noreferrer">lunchmoney-mcp</a> is a popular choice — it works well with Claude Desktop (including a one-click `.mcpb` bundle install), covers the full v2 API, and has straightforward setup instructions.
+
+With MCP, your access token usually lives in a local configuration file on your computer — not in the chat window — which is safer than pasting it directly into a conversation.
+
+> [!WARNING]
+> When an AI assistant answers a question using MCP, the relevant Lunch Money data may be sent through the AI provider to generate the response. Review the MCP server's documentation and your AI provider's data-handling policy before connecting.
+
+## Option 2: Use an AI coding assistant to build your own tools
+
+If you're comfortable writing code, another approach is to point an AI coding assistant at the [Lunch Money OpenAPI spec](/v2/openapi) and ask it to help you build exactly what you need. For example:
+
+- "Using the Lunch Money v2 OpenAPI spec, write a script that lists all uncategorized transactions."
+- "Create a report of transactions over $500 from the last 90 days."
+- "Help me make a chart of monthly spending by category."
+
+This is a useful middle path: the AI helps write code against the public API docs, while your actual financial data stays between your computer and Lunch Money unless you explicitly share it.
+
+> [!TIP]
+> If an AI coding assistant is only helping you write code from the public API docs, it may not need to see any of your financial data at all. Keep data out of the chat and run the resulting scripts locally.
+
+### Keeping your token out of the conversation
+
+The safest way to supply your access token to a local script is to keep it out of the prompt entirely — let the program read it at runtime instead:
+
+:::tabs
+@tab bash / curl
+```bash
+# Set once in your shell or add to your shell config file
+export LUNCH_MONEY_ACCESS_TOKEN="your_token_here"
+
+# Scripts and curl commands read it automatically
+curl https://api.lunchmoney.dev/v2/me \
+  -H "Authorization: Bearer $LUNCH_MONEY_ACCESS_TOKEN"
+```
+
+@tab Python
+```python
+# .env file (add to .gitignore — do not commit to source control)
+# LUNCH_MONEY_ACCESS_TOKEN=your_token_here
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+token = os.environ["LUNCH_MONEY_ACCESS_TOKEN"]
+```
+
+@tab Node.js
+```javascript
+// .env file (add to .gitignore — do not commit to source control)
+// LUNCH_MONEY_ACCESS_TOKEN=your_token_here
+
+import 'dotenv/config';
+const token = process.env.LUNCH_MONEY_ACCESS_TOKEN;
+```
+:::
+
+> [!WARNING]
+> Avoid pasting your access token directly into an AI chat window. Treat it like a password — store it in an environment variable, a `.env` file excluded from source control, or your operating system's secret store.
+
+## Best Practices
+
+1. **Start with a test budget** — API changes are permanent. Use a test budget while you're learning so your real data stays safe. See the [Getting Started guide](/getting-started) for instructions.
+
+2. **Prefer read-only workflows** — A workflow that only reads data is lower risk than one that can create, update, or delete records.
+
+3. **Give tokens descriptive names** — Label each token clearly on the <a href="https://my.lunchmoney.app/developers" target="_blank" rel="noopener noreferrer">Developers page</a> so you can identify and revoke them easily later.
+
+4. **Create one token per tool** — That way you can revoke a specific integration without affecting others. You cannot unsend data that has already been shared, but you can always cut off future access.
+
+5. **Understand what you're sharing** — The more data you send to a third-party service, the more carefully you should review that service's privacy and data-retention policies.
+
+## Starter ideas
+
+If you want to experiment, here are a few low-risk starting points:
+
+1. Ask an MCP-connected assistant to summarize your spending by category for the current month.
+2. Use an AI coding assistant to help write a script that lists all uncategorized transactions.
+3. Generate a simple monthly cash-flow report from your API data.
+4. Ask for patterns in merchant names that might deserve new rules or categories.
+5. Build a reusable "money questions" notebook with prompts you revisit each month.
+
+Start small, and use a test budget while you're learning.
+
+## Need Help?
+
+- Join the <a href="https://lunchmoney.app/discord" target="_blank" rel="noopener noreferrer">Lunch Money Discord</a> and ask in the **#developer-api** channel
+- [Email our developer advocate](mailto:jp@lunchmoney.app)

package/manifest.json

@@ -0,0 +1,225 @@
+{
+  "$comment": "Doc routing manifest (plans/remove_submodule.md, Phase 2). Pages, redirects, and sidebar for all documentation routes. 'file' paths are relative to the @lunch-money/developer-docs package root. Page 'aliases' are 301 redirects to the page path; 'redirects' entries carry their own status.",
+  "pages": [
+    {
+      "path": "/introduction",
+      "file": "docs/introduction.md",
+      "title": "Introduction",
+      "section": "INTRODUCTION",
+      "type": "markdown",
+      "aliases": ["/v2/introduction"]
+    },
+    {
+      "path": "/getting-started",
+      "file": "docs/getting-started.md",
+      "title": "Getting Started",
+      "section": "GUIDES",
+      "type": "markdown",
+      "aliases": ["/v2/getting-started"]
+    },
+    {
+      "path": "/pagination",
+      "file": "docs/pagination.md",
+      "title": "Pagination",
+      "section": "GUIDES",
+      "type": "markdown",
+      "aliases": ["/v2/pagination"]
+    },
+    {
+      "path": "/rate-limits",
+      "file": "docs/rate-limiting.md",
+      "title": "Rate Limiting",
+      "section": "GUIDES",
+      "type": "markdown",
+      "aliases": ["/v2/rate-limits"]
+    },
+    {
+      "path": "/currencies",
+      "file": "docs/currencies.md",
+      "title": "Supported Currencies",
+      "section": "GUIDES",
+      "type": "markdown",
+      "aliases": ["/v2/currencies"]
+    },
+    {
+      "path": "/amounts-and-balances",
+      "file": "docs/amounts-and-balances.md",
+      "title": "Amounts & Balances",
+      "section": "GUIDES",
+      "type": "markdown",
+      "aliases": ["/v2/amounts-and-balances"]
+    },
+    {
+      "path": "/using-with-ai",
+      "file": "docs/using-with-ai.md",
+      "title": "Using the API with AI",
+      "section": "GUIDES",
+      "type": "markdown",
+      "aliases": ["/v2/using-with-ai"]
+    },
+    {
+      "path": "/v2/overview",
+      "file": "v2/docs/intro-to-v2.md",
+      "title": "v2 API Overview",
+      "section": "REFERENCE",
+      "type": "markdown"
+    },
+    {
+      "path": "/v2/changelog",
+      "file": "v2/docs/version-history.md",
+      "title": "v2 API Changelog",
+      "section": "REFERENCE",
+      "type": "markdown",
+      "aliases": ["/v2/version-history"]
+    },
+    {
+      "path": "/v2/migration-guide",
+      "file": "v2/docs/migration-guide.md",
+      "title": "Migrating v1 to v2",
+      "section": "LEGACY APIs",
+      "type": "markdown"
+    },
+    {
+      "path": "/v2/changelog-visual",
+      "file": "v2/docs/changelog-visual.html",
+      "title": "v2 API Visual Changelog",
+      "section": "REFERENCE",
+      "type": "html"
+    },
+    {
+      "path": "/v1/changelog",
+      "file": "v1/_changelog.md",
+      "title": "v1 Changelog",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/changelog"]
+    },
+    {
+      "path": "/v1/user",
+      "file": "v1/_user.md",
+      "title": "v1 User",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/user"]
+    },
+    {
+      "path": "/v1/categories",
+      "file": "v1/_categories.md",
+      "title": "v1 Categories",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/categories"]
+    },
+    {
+      "path": "/v1/tags",
+      "file": "v1/_tags.md",
+      "title": "v1 Tags",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/tags"]
+    },
+    {
+      "path": "/v1/transactions",
+      "file": "v1/_transactions.md",
+      "title": "v1 Transactions",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/transactions"]
+    },
+    {
+      "path": "/v1/recurring-expenses",
+      "file": "v1/_recurring_expenses.md",
+      "title": "v1 Recurring Expenses",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/recurring-expenses"]
+    },
+    {
+      "path": "/v1/recurring-items",
+      "file": "v1/_recurring_items.md",
+      "title": "v1 Recurring Items",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/recurring-items"]
+    },
+    {
+      "path": "/v1/budget",
+      "file": "v1/_budget.md",
+      "title": "v1 Budget",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/budget"]
+    },
+    {
+      "path": "/v1/assets",
+      "file": "v1/_assets.md",
+      "title": "v1 Assets",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/assets"]
+    },
+    {
+      "path": "/v1/plaid-accounts",
+      "file": "v1/_plaid_accounts.md",
+      "title": "v1 Plaid Accounts",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/plaid-accounts"]
+    },
+    {
+      "path": "/v1/crypto",
+      "file": "v1/_crypto.md",
+      "title": "v1 Crypto",
+      "section": "V1 API REFERENCE",
+      "type": "v1-slate",
+      "aliases": ["/v1/reference/crypto"]
+    }
+  ],
+  "redirects": [
+    { "from": "/", "to": "/introduction", "status": 302 },
+    { "from": "/v2", "to": "/introduction", "status": 302 },
+    { "from": "/v2/", "to": "/introduction", "status": 302 },
+    { "from": "/v1", "to": "/v1/user", "status": 302 },
+    { "from": "/v1/docs", "to": "/v1/user", "status": 301 }
+  ],
+  "sidebar": {
+    "docs": [
+      { "label": "Introduction", "path": "/introduction" },
+      { "section": "GUIDES", "items": [
+        { "label": "Getting Started", "path": "/getting-started" },
+        { "label": "Amounts & Balances", "path": "/amounts-and-balances" },
+        { "label": "Pagination", "path": "/pagination" },
+        { "label": "Rate Limiting", "path": "/rate-limits" },
+        { "label": "Supported Currencies", "path": "/currencies" },
+        { "label": "Using the API with AI", "path": "/using-with-ai" }
+      ]},
+      { "section": "REFERENCE", "items": [
+        { "label": "v2 API Overview", "path": "/v2/overview" },
+        { "label": "v2 API Reference", "path": "/v2/docs", "external": true },
+        { "label": "v2 API Changelog", "path": "/v2/changelog" }
+      ]},
+      { "section": "LEGACY APIs", "items": [
+        { "label": "Migrating v1 → v2", "path": "/v2/migration-guide" },
+        { "label": "v1 API Reference", "path": "/v1/user", "external": true },
+        { "label": "v1 API Changelog", "path": "/v1/changelog" },
+        { "label": "Legacy v1 docs", "path": "https://v1.lunchmoney.dev/", "external": true }
+      ]}
+    ],
+    "v1": [
+      { "section": "V1 API REFERENCE", "items": [
+        { "label": "User", "path": "/v1/user" },
+        { "label": "Categories", "path": "/v1/categories" },
+        { "label": "Tags", "path": "/v1/tags" },
+        { "label": "Transactions", "path": "/v1/transactions" },
+        { "label": "Recurring Expenses", "path": "/v1/recurring-expenses" },
+        { "label": "Recurring Items", "path": "/v1/recurring-items" },
+        { "label": "Budget", "path": "/v1/budget" },
+        { "label": "Assets", "path": "/v1/assets" },
+        { "label": "Plaid Accounts", "path": "/v1/plaid-accounts" },
+        { "label": "Crypto", "path": "/v1/crypto" }
+      ]},
+      { "label": "v1 API Changelog", "path": "/v1/changelog" },
+      { "label": "Legacy v1 docs", "path": "https://v1.lunchmoney.dev/", "external": true }
+    ]
+  }
+}