nuxt-openapi-hyperfetch 1.0.2 → 1.0.4

package/dist/generators/connectors/config-resolver.js

@@ -0,0 +1,207 @@
+import { camelCase, pascalCase } from 'change-case';
+import { mapColumnsFromSchema, mapFieldsFromSchema, buildZodSchema, } from '../components/schema-analyzer/index.js';
+function toConnectorName(tag) {
+    const pascal = pascalCase(tag);
+    const plural = /(?:s|x|z|ch|sh)$/i.test(pascal) ? `${pascal}es` : `${pascal}s`;
+    return `use${plural}Connector`;
+}
+function cloneResource(resource) {
+    return {
+        ...resource,
+        endpoints: [...resource.endpoints],
+        columns: [...resource.columns],
+        formFields: {
+            ...(resource.formFields.create ? { create: [...resource.formFields.create] } : {}),
+            ...(resource.formFields.update ? { update: [...resource.formFields.update] } : {}),
+        },
+        zodSchemas: { ...resource.zodSchemas },
+    };
+}
+function getRefNameFromSchema(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    const directRef = schema['x-ref-name'];
+    if (typeof directRef === 'string') {
+        return directRef;
+    }
+    const items = schema.items;
+    if (items && typeof items === 'object') {
+        const itemRef = items['x-ref-name'];
+        if (typeof itemRef === 'string') {
+            return itemRef;
+        }
+    }
+    return undefined;
+}
+function rebuildDerived(resource) {
+    const schemaForColumns = resource.listEndpoint?.responseSchema ?? resource.detailEndpoint?.responseSchema;
+    resource.columns = schemaForColumns ? mapColumnsFromSchema(schemaForColumns) : [];
+    resource.formFields = {
+        ...(resource.createEndpoint?.requestBodySchema
+            ? { create: mapFieldsFromSchema(resource.createEndpoint.requestBodySchema) }
+            : {}),
+        ...(resource.updateEndpoint?.requestBodySchema
+            ? { update: mapFieldsFromSchema(resource.updateEndpoint.requestBodySchema) }
+            : {}),
+    };
+    resource.zodSchemas = {
+        ...(resource.createEndpoint?.requestBodySchema
+            ? { create: buildZodSchema(resource.createEndpoint.requestBodySchema) }
+            : {}),
+        ...(resource.updateEndpoint?.requestBodySchema
+            ? { update: buildZodSchema(resource.updateEndpoint.requestBodySchema) }
+            : {}),
+    };
+    resource.itemTypeName =
+        getRefNameFromSchema(resource.detailEndpoint?.responseSchema) ??
+            getRefNameFromSchema(resource.listEndpoint?.responseSchema) ??
+            undefined;
+}
+function expectedMethodsForOperation(operationName) {
+    switch (operationName) {
+        case 'getAll':
+        case 'get':
+            return ['GET'];
+        case 'create':
+            return ['POST'];
+        case 'update':
+            return ['PUT', 'PATCH'];
+        case 'delete':
+            return ['DELETE'];
+    }
+}
+function selectByIntent(operationName, candidates) {
+    if (operationName === 'getAll') {
+        const preferred = candidates.filter((c) => c.intent === 'list');
+        return preferred.length > 0 ? preferred : candidates;
+    }
+    if (operationName === 'get') {
+        const preferred = candidates.filter((c) => c.intent === 'detail');
+        return preferred.length > 0 ? preferred : candidates;
+    }
+    if (operationName === 'update') {
+        const put = candidates.filter((c) => c.method === 'PUT');
+        return put.length > 0 ? put : candidates;
+    }
+    return candidates;
+}
+function buildEndpointIndex(resourceMap) {
+    const byOperationId = new Map();
+    const byPath = new Map();
+    for (const resource of resourceMap.values()) {
+        for (const endpoint of resource.endpoints) {
+            byOperationId.set(endpoint.operationId, endpoint);
+            const list = byPath.get(endpoint.path) ?? [];
+            list.push(endpoint);
+            byPath.set(endpoint.path, list);
+        }
+    }
+    return { byOperationId, byPath };
+}
+function resolveEndpoint(operationName, operationConfig, endpointIndex, resourceName) {
+    if (operationConfig.operationId && operationConfig.path) {
+        throw new Error(`[connectors] Resource "${resourceName}" operation "${operationName}" cannot define both operationId and path`);
+    }
+    if (!operationConfig.operationId && !operationConfig.path) {
+        throw new Error(`[connectors] Resource "${resourceName}" operation "${operationName}" must define operationId or path`);
+    }
+    if (operationConfig.operationId) {
+        const endpoint = endpointIndex.byOperationId.get(operationConfig.operationId);
+        if (!endpoint) {
+            throw new Error(`[connectors] Resource "${resourceName}" operation "${operationName}" references unknown operationId "${operationConfig.operationId}"`);
+        }
+        return endpoint;
+    }
+    const candidates = endpointIndex.byPath.get(operationConfig.path) ?? [];
+    if (candidates.length === 0) {
+        throw new Error(`[connectors] Resource "${resourceName}" operation "${operationName}" references unknown path "${operationConfig.path}"`);
+    }
+    const validMethods = expectedMethodsForOperation(operationName);
+    const byMethod = candidates.filter((c) => validMethods.includes(c.method));
+    if (byMethod.length === 0) {
+        throw new Error(`[connectors] Resource "${resourceName}" operation "${operationName}" path "${operationConfig.path}" has no compatible method (${validMethods.join('/')})`);
+    }
+    const prioritized = selectByIntent(operationName, byMethod);
+    return prioritized[0];
+}
+function setOperationEndpoint(resource, operationName, endpoint) {
+    switch (operationName) {
+        case 'getAll':
+            resource.listEndpoint = endpoint;
+            break;
+        case 'get':
+            resource.detailEndpoint = endpoint;
+            break;
+        case 'create':
+            resource.createEndpoint = endpoint;
+            break;
+        case 'update':
+            resource.updateEndpoint = endpoint;
+            break;
+        case 'delete':
+            resource.deleteEndpoint = endpoint;
+            break;
+    }
+    if (!resource.endpoints.some((ep) => ep.operationId === endpoint.operationId)) {
+        resource.endpoints.push(endpoint);
+    }
+}
+function createResourceSkeleton(resourceKey) {
+    return {
+        name: pascalCase(resourceKey),
+        tag: resourceKey,
+        composableName: toConnectorName(resourceKey),
+        endpoints: [],
+        columns: [],
+        formFields: {},
+        zodSchemas: {},
+    };
+}
+function applyResourceOverrides(target, resourceName, config, endpointIndex) {
+    const operations = config.operations ?? {};
+    for (const [operationName, operationConfig] of Object.entries(operations)) {
+        if (!operationConfig) {
+            continue;
+        }
+        const endpoint = resolveEndpoint(operationName, operationConfig, endpointIndex, resourceName);
+        setOperationEndpoint(target, operationName, endpoint);
+    }
+    rebuildDerived(target);
+    return target;
+}
+function normalizeConfig(config) {
+    return {
+        strategy: config?.strategy ?? 'hybrid',
+        ...config,
+    };
+}
+export function resolveConnectorResourceMap(baseResourceMap, connectorsConfig) {
+    if (!connectorsConfig) {
+        return baseResourceMap;
+    }
+    const normalized = normalizeConfig(connectorsConfig);
+    const resourceConfigs = normalized.resources ?? {};
+    const endpointIndex = buildEndpointIndex(baseResourceMap);
+    if (normalized.strategy === 'manual') {
+        const manualMap = new Map();
+        for (const [resourceName, resourceConfig] of Object.entries(resourceConfigs)) {
+            const resourceKey = camelCase(resourceName);
+            const baseResource = baseResourceMap.get(resourceKey);
+            const target = baseResource
+                ? cloneResource(baseResource)
+                : createResourceSkeleton(resourceName);
+            applyResourceOverrides(target, resourceName, resourceConfig, endpointIndex);
+            manualMap.set(resourceKey, target);
+        }
+        return manualMap;
+    }
+    const hybridMap = new Map([...baseResourceMap.entries()].map(([key, value]) => [key, cloneResource(value)]));
+    for (const [resourceName, resourceConfig] of Object.entries(resourceConfigs)) {
+        const resourceKey = camelCase(resourceName);
+        const target = hybridMap.get(resourceKey) ?? createResourceSkeleton(resourceName);
+        applyResourceOverrides(target, resourceName, resourceConfig, endpointIndex);
+        hybridMap.set(resourceKey, target);
+    }
+    return hybridMap;
+}

package/dist/generators/connectors/generator.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import { format } from 'prettier';
 import { analyzeSpec } from '../components/schema-analyzer/index.js';
 import { generateConnectorFile, connectorFileName, generateConnectorIndexFile, } from './templates.js';
+import { resolveConnectorResourceMap } from './config-resolver.js';
 import { createClackLogger } from '../../cli/logger.js';
 // Runtime files that must be copied to the user's project
 const RUNTIME_FILES = [
@@ -44,7 +45,8 @@ export async function generateConnectors(options, logger = createClackLogger())
     const runtimeRelDir = options.runtimeRelDir ?? '../runtime';
     // ── 1. Analyze spec ───────────────────────────────────────────────────────
     spinner.start('Analyzing OpenAPI spec');
-    const resourceMap = analyzeSpec(options.inputSpec);
+    const baseResourceMap = analyzeSpec(options.inputSpec);
+    const resourceMap = resolveConnectorResourceMap(baseResourceMap, options.connectorsConfig);
     spinner.stop(`Found ${resourceMap.size} resource(s)`);
     if (resourceMap.size === 0) {
         logger.log.warn('No resources found in spec — nothing to generate');

package/dist/generators/connectors/templates.js

@@ -150,6 +150,7 @@ function buildOptionsInterface(resource) {
     if (resource.listEndpoint && hasColumns) {
         fields.push(`  columnLabels?: Record<string, string>;`);
         fields.push(`  columnLabel?: (key: string) => string;`);
+        fields.push(`  getAllRequestOptions?: Record<string, unknown>;`);
     }
     if (resource.createEndpoint && resource.zodSchemas.create) {
         const pascal = pascalCase(resource.name);
@@ -218,7 +219,10 @@ function buildFunctionBody(resource) {
     // Options destructure
     const optionKeys = [];
     if (resource.listEndpoint && hasColumns) {
-        optionKeys.push('columnLabels', 'columnLabel');
+        optionKeys.push('columnLabels', 'columnLabel', 'getAllRequestOptions');
+    }
+    else if (resource.listEndpoint) {
+        optionKeys.push('getAllRequestOptions');
     }
     if (resource.createEndpoint && resource.zodSchemas.create) {
         optionKeys.push('createSchema');
@@ -257,7 +261,7 @@ function buildFunctionBody(resource) {
         const labelArgs = hasColumns ? 'columnLabels, columnLabel' : '';
         const allArgs = [columnsArg, labelArgs].filter(Boolean).join(', ');
         const opts = allArgs ? `{ ${allArgs} }` : '{}';
-        lines.push(`  const isFactory = typeof paramsOrSource === 'function';`, `  const listFactory = isFactory`, `    ? (paramsOrSource as () => unknown)`, `    : () => ${fn}((paramsOrSource ?? {}) as ${listRequestTypeName});`, `  const getAll = useGetAllConnector(listFactory, ${opts}) as unknown as GetAllConnectorReturn<${pascal}>;`);
+        lines.push(`  const isFactory = typeof paramsOrSource === 'function';`, `  const listFactory = isFactory`, `    ? (paramsOrSource as () => unknown)`, `    : () => ${fn}((paramsOrSource ?? {}) as ${listRequestTypeName}, { paginated: true, ...(getAllRequestOptions ?? {}) });`, `  const getAll = useGetAllConnector(listFactory, ${opts}) as unknown as GetAllConnectorReturn<${pascal}>;`);
     }
     else {
         lines.push(`  const getAll = useGetAllConnector(() => ({}), {}) as unknown as GetAllConnectorReturn<${pascal}>;`);

package/dist/generators/connectors/types.d.ts

@@ -4,6 +4,7 @@
  * The Connector Generator reads the ResourceMap produced by the Schema Analyzer
  * and writes one `use{Resource}Connector.ts` file per resource using $fetch for mutations.
  */
+import type { ConnectorsConfig } from '../../config/types.js';
 export interface ConnectorGeneratorOptions {
     /** Absolute or relative path to the OpenAPI YAML/JSON spec */
     inputSpec: string;
@@ -24,6 +25,8 @@ export interface ConnectorGeneratorOptions {
      * useRuntimeConfig().public.apiBaseUrl at runtime.
      */
     baseUrl?: string;
+    /** Advanced connectors configuration (manual/hybrid, custom resources, overloads). */
+    connectorsConfig?: ConnectorsConfig;
 }
 export interface ConnectorFileInfo {
     /** PascalCase resource name. E.g. 'Pet' */

package/dist/index.js

@@ -9,7 +9,8 @@ import { generateConnectors } from './generators/connectors/generator.js';
 import { promptInitialInputs, promptInputPath, promptComposablesSelection, promptServerRoutePath, promptBffConfig, promptGeneratorBackend, promptConnectors, } from './cli/prompts.js';
 import { MESSAGES } from './cli/messages.js';
 import { displayLogo } from './cli/logo.js';
-import { loadConfig, mergeConfig, parseTags, parseGenerators } from './cli/config.js';
+import { loadConfig, mergeConfig, parseTags, parseGenerators, normalizeGenerators, } from './cli/config.js';
+import { hasConnectorsConfig } from './config/connectors.js';
 const program = new Command();
 program.name('nxh').description('Nuxt OpenAPI Hyperfetch generator').version('1.0.0');
 program
@@ -25,7 +26,7 @@ program
     .option('--dry-run', 'Preview changes without writing files', false)
     .option('-v, --verbose', 'Enable verbose logging', false)
     .option('--watch', 'Watch mode - regenerate on file changes', false)
-    .option('--generators <types>', 'Generators to use: useFetch,useAsyncData,nuxtServer')
+    .option('--generators <types>', 'Generators to use: useFetch,useAsyncData,nuxtServer,connectors')
     .option('--connectors', 'Generate headless UI connectors on top of useAsyncData', false)
     .option('--server-route-path <path>', 'Server route path (for nuxtServer mode)')
     .option('--enable-bff', 'Enable BFF pattern (for nuxtServer mode)', false)
@@ -86,16 +87,21 @@ program
         }
         // 1. Determine composables to generate FIRST
         let composables;
+        let generateConnectorsFlag = false;
+        const connectorsConfigured = hasConnectorsConfig(config.connectors);
         if (config.generators) {
-            // filter out 'connectors' — handled separately below
-            composables = config.generators.filter((g) => g !== 'connectors');
+            const normalized = normalizeGenerators(config.generators, config.createUseAsyncDataConnectors);
+            composables = normalized.composables;
+            generateConnectorsFlag = normalized.generateConnectors;
             if (config.verbose) {
                 console.log(`Using generators from config: ${composables.join(', ')}`);
             }
         }
         else {
             const result = await promptComposablesSelection();
-            composables = result.composables;
+            const normalized = normalizeGenerators(result.composables, config.createUseAsyncDataConnectors);
+            composables = normalized.composables;
+            generateConnectorsFlag = normalized.generateConnectors;
         }
         if (composables.length === 0) {
             p.outro(MESSAGES.outro.noComposables);
@@ -117,14 +123,24 @@ program
             inputPath = await promptInputPath(config.input);
             outputPath = config.output ?? './swagger';
         }
-        // 3. Ask whether to generate headless connectors (only if useAsyncData selected)
-        let generateConnectorsFlag = false;
+        // 3. Ask whether to generate headless connectors (only if still unresolved)
         if (composables.includes('useAsyncData')) {
-            if (config.createUseAsyncDataConnectors !== undefined) {
+            const hasExplicitConnectorsInGenerators = config.generators?.includes('connectors') ?? false;
+            const shouldPromptConnectors = !generateConnectorsFlag &&
+                config.createUseAsyncDataConnectors === undefined &&
+                !hasExplicitConnectorsInGenerators &&
+                !connectorsConfigured;
+            if (shouldPromptConnectors) {
+                generateConnectorsFlag = await promptConnectors();
+            }
+            else if (connectorsConfigured) {
+                generateConnectorsFlag = true;
+            }
+            else if (config.createUseAsyncDataConnectors !== undefined) {
                 generateConnectorsFlag = config.createUseAsyncDataConnectors;
             }
-            else {
-                generateConnectorsFlag = await promptConnectors();
+            else if (hasExplicitConnectorsInGenerators) {
+                generateConnectorsFlag = true;
             }
         }
         // 4. Ask for server route path if nuxtServer is selected
@@ -203,6 +219,7 @@ program
                         outputDir: `${composablesOutputDir}/connectors`,
                         composablesRelDir: '../use-async-data/composables',
                         runtimeRelDir: '../../runtime',
+                        connectorsConfig: config.connectors,
                     });
                     spinner.stop('✓ Generated headless UI connectors');
                 }

package/dist/module/index.js

@@ -7,6 +7,8 @@ import { generateUseAsyncDataComposables } from '../generators/use-async-data/ge
 import { generateNuxtServerRoutes } from '../generators/nuxt-server/generator.js';
 import { generateConnectors } from '../generators/connectors/generator.js';
 import { createConsoleLogger } from '../cli/logger.js';
+import { normalizeGenerators } from '../cli/config.js';
+import { isConnectorsRequested } from '../config/connectors.js';
 export default defineNuxtModule({
     meta: {
         name: 'nuxt-openapi-hyperfetch',
@@ -32,7 +34,10 @@ export default defineNuxtModule({
         const resolvedInput = path.resolve(nuxt.options.rootDir, options.input);
         const resolvedOutput = path.resolve(nuxt.options.rootDir, options.output);
         const composablesOutputDir = path.join(resolvedOutput, 'composables');
-        const selectedGenerators = options.generators ?? ['useFetch', 'useAsyncData'];
+        const normalized = normalizeGenerators(options.generators ?? ['useFetch', 'useAsyncData'], options.createUseAsyncDataConnectors);
+        const selectedGenerators = normalized.composables;
+        const generateConnectorsFlag = normalized.generateConnectors;
+        const connectorsRequested = isConnectorsRequested(options);
         const backend = options.backend ?? 'heyapi';
         const logger = createConsoleLogger();
         // --- Core generation function ---
@@ -67,13 +72,15 @@ export default defineNuxtModule({
                 await generateNuxtServerRoutes(resolvedOutput, serverRoutePath, { enableBff: options.enableBff, backend }, logger);
             }
             // 3. Generate headless connectors if requested (requires useAsyncData)
-            if (options.createUseAsyncDataConnectors && selectedGenerators.includes('useAsyncData')) {
+            if ((generateConnectorsFlag || connectorsRequested) &&
+                selectedGenerators.includes('useAsyncData')) {
                 const connectorsOutputDir = path.join(composablesOutputDir, 'connectors');
                 await generateConnectors({
                     inputSpec: resolvedInput,
                     outputDir: connectorsOutputDir,
                     composablesRelDir: '../use-async-data/composables',
                     runtimeRelDir: '../../runtime',
+                    connectorsConfig: options.connectors,
                 }, logger);
             }
         };
@@ -100,7 +107,8 @@ export default defineNuxtModule({
             if (selectedGenerators.includes('useAsyncData')) {
                 addImportsDir(path.join(composablesOutputDir, 'use-async-data', 'composables'));
             }
-            if (options.createUseAsyncDataConnectors && selectedGenerators.includes('useAsyncData')) {
+            if ((generateConnectorsFlag || connectorsRequested) &&
+                selectedGenerators.includes('useAsyncData')) {
                 addImportsDir(path.join(composablesOutputDir, 'connectors'));
             }
         }

package/dist/module/types.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorConfig } from '../cli/config.js';
+import type { GeneratorConfig } from '../config/types.js';
 /**
  * Configuration options for the nuxt-openapi-hyperfetch Nuxt module.
  * Extends the CLI GeneratorConfig so the same fields work in both nxh.config.js and nuxt.config.ts.
@@ -25,9 +25,9 @@ export interface ModuleOptions extends GeneratorConfig {
      */
     enableAutoImport?: boolean;
     /**
-     * Generate headless UI connector composables on top of useAsyncData.
-     * Connectors provide ready-made logic for tables, pagination, forms and delete actions.
-     * Requires useAsyncData to also be in generators.
+     * Backward-compatible connectors flag.
+     * Prefer `generators: ['connectors']` so module and CLI behave the same.
+     * When true, connectors are generated and useAsyncData is added automatically.
      * @default false
      */
     createUseAsyncDataConnectors?: boolean;

package/docs/QUICK-START.md

@@ -15,10 +15,10 @@ OpenAPI/Swagger → TypeScript Client → Nuxt Composables
 
 The tool supports two backends for **Stage 1** (OpenAPI → TypeScript Client). You choose at runtime:
 
-| Backend | Command | Requires | Output format |
-|---|---|---|---|
-| **OpenAPI Generator** (official) | `@openapitools/openapi-generator-cli` | Java 11+ | `apis/PetApi.ts`, `models/` |
-| **Hey API** | `@hey-api/openapi-ts` | Node.js only | `sdk.gen.ts`, `types.gen.ts` |
+| Backend                          | Command                               | Requires     | Output format                |
+| -------------------------------- | ------------------------------------- | ------------ | ---------------------------- |
+| **OpenAPI Generator** (official) | `@openapitools/openapi-generator-cli` | Java 11+     | `apis/PetApi.ts`, `models/`  |
+| **Hey API**                      | `@hey-api/openapi-ts`                 | Node.js only | `sdk.gen.ts`, `types.gen.ts` |
 
 Both produce the same final Nuxt composables. The choice affects only Stage 1 output and the parser used in Stage 2.
 
@@ -98,6 +98,16 @@ useFetchAddPet → useApiRequest → useFetch (Nuxt native)
 | Plugin templates | ❌         | ✅ (once)       | ✅ (safe)        |
 | CLI tool itself  | ❌         | ❌              | ✅ (you edit)    |
 
+### 4. Generator Selection Semantics (CLI + Nuxt module)
+
+Generator selection is unified between `nxh.config.*` and `nuxt.config.ts`.
+
+- `generators: ['connectors']` runs `useAsyncData` first, then `connectors`
+- `generators: ['useAsyncData']` runs only `useAsyncData`
+- `generators: ['useAsyncData', 'connectors']` runs both
+
+`createUseAsyncDataConnectors` remains available for backward compatibility, but `generators: ['connectors']` is the preferred declarative option.
+
 ## Key Files (Read These First)
 
 ### 1. **CLI Entry** - `src/index.ts`
@@ -231,6 +241,36 @@ nuxt-generator/
 
 ## Most Common Tasks
 
+### Configure Connectors (manual/hybrid)
+
+Use `connectors` in `nxh.config.ts` or `openApiHyperFetch` in `nuxt.config.ts`.
+
+```ts
+connectors: {
+  strategy: 'hybrid',
+  resources: {
+    pets: {
+      operations: {
+        getAll: { operationId: 'findPetsByStatus' },
+        get: { path: '/pet/{petId}' }
+      }
+    },
+    featuredPets: {
+      operations: {
+        getAll: { operationId: 'findPetsByTags' }
+      }
+    }
+  }
+}
+```
+
+Rules:
+
+- Each operation accepts `operationId` or `path` (never both)
+- Partial override is allowed (you can define only `get` and `getAll`)
+- `manual` generates only configured resources
+- `hybrid` merges inferred resources with configured overrides/custom resources
+
 ### Debugging a Parser Error
 
 1. Check error message for method name

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-openapi-hyperfetch",
-  "version": "1.0.2",
-  "description": "Nuxt useFetch, useAsyncData, Nuxt server & Headless UI connectors OpenAPI generator",
+  "version": "1.0.4",
+  "description": "⚡ OpenAPI to Nuxt code generator for useFetch, useAsyncData, server routes, and headless CRUD connectors.",
   "type": "module",
   "author": "",
   "license": "Apache-2.0",
@@ -86,9 +86,28 @@
     "fs-extra": "^11.3.4",
     "globby": "^16.1.1",
     "gradient-string": "^3.0.0",
+    "jiti": "^2.6.1",
     "js-yaml": "^4.1.1",
     "prettier": "^3.8.1",
     "ts-morph": "^27.0.2"
   },
-  "keywords": ["nuxt", "openapi", "swagger", "codegen", "composables", "useFetch", "useAsyncData", "typescript", "zod", "connector"]
+  "keywords": [
+    "openapi",
+    "generator",
+    "nuxt",
+    "rest",
+    "composables",
+    "swagger",
+    "fetch",
+    "$fetch",
+    "useFetch",
+    "useAsyncData",
+    "api",
+    "open",
+    "codegen",
+    "server",
+    "node",
+    "headless",
+    "sdk"
+  ]
 }