nuxt-openapi-hyperfetch 0.3.8-beta → 1.0.0

package/dist/generators/components/connector-generator/templates.js

@@ -23,8 +23,8 @@ function toAsyncDataName(operationId) {
     return `useAsyncData${pascalCase(operationId)}`;
 }
 /**
- * composable name → PascalCase file name (without .ts), matching useAsyncData generator output.
- * 'useAsyncDataGetPets' → 'useAsyncDataGetPets'
+ * composable name → kebab-case file name (without .ts).
+ * 'useAsyncDataGetPets' → 'use-async-data-get-pets'
  */
 function toFileName(composableName) {
     return composableName;
@@ -35,14 +35,20 @@ function toFileName(composableName) {
  */
 function buildImports(resource, composablesRelDir, sdkRelDir, runtimeRelDir) {
     const lines = [];
+    // vue — shallowRef needed when form, delete, or detail endpoints exist
+    const needsShallowRef = !!(resource.createEndpoint ||
+        resource.updateEndpoint ||
+        resource.deleteEndpoint ||
+        resource.detailEndpoint);
+    const needsComputed = !!resource.detailEndpoint;
+    if (needsShallowRef) {
+        const vueImports = needsComputed ? `shallowRef, computed` : `shallowRef`;
+        lines.push(`import { ${vueImports} } from 'vue';`);
+        lines.push('');
+    }
     // zod
     lines.push(`import { z } from 'zod';`);
     lines.push('');
-    // Vue — computed needed for the detail connector wrapper
-    if (resource.detailEndpoint) {
-        lines.push(`import { computed } from 'vue';`);
-        lines.push('');
-    }
     // connector-types — structural interfaces for return types
     const connectorTypeImports = ['ListConnectorReturn'];
     if (resource.detailEndpoint) {
@@ -160,6 +166,12 @@ function buildOptionsInterface(resource) {
     if (resource.updateEndpoint && resource.zodSchemas.update) {
         fields.push(`  updateSchema?: z.ZodTypeAny | ((base: z.ZodTypeAny) => z.ZodTypeAny);`);
     }
+    if (resource.createEndpoint || resource.updateEndpoint || resource.deleteEndpoint) {
+        fields.push(`  onRequest?: (ctx: any) => void | Promise<void>;`);
+        fields.push(`  onSuccess?: (data: any) => void;`);
+        fields.push(`  onError?: (err: any) => void;`);
+        fields.push(`  onFinish?: () => void;`);
+    }
     if (fields.length === 0) {
         return `type ${typeName} = Record<string, never>;`;
     }
@@ -185,11 +197,15 @@ function buildReturnType(resource) {
         fields.push(`  detail: DetailConnectorReturn<${pascal}>;`);
     }
     if (resource.createEndpoint) {
-        const inputType = resource.zodSchemas.create ? `${pascal}CreateInput` : `Record<string, unknown>`;
+        const inputType = resource.zodSchemas.create
+            ? `${pascal}CreateInput`
+            : `Record<string, unknown>`;
         fields.push(`  createForm: FormConnectorReturn<${inputType}>;`);
     }
     if (resource.updateEndpoint) {
-        const inputType = resource.zodSchemas.update ? `${pascal}UpdateInput` : `Record<string, unknown>`;
+        const inputType = resource.zodSchemas.update
+            ? `${pascal}UpdateInput`
+            : `Record<string, unknown>`;
         fields.push(`  updateForm: FormConnectorReturn<${inputType}>;`);
     }
     if (resource.deleteEndpoint) {
@@ -197,6 +213,17 @@ function buildReturnType(resource) {
     }
     return [`type ${typeName} = {`, ...fields, `};`].join('\n');
 }
+/**
+ * Build the 3 generated lines for a composable that is keyed by a single path param
+ * (detail, delete). Uses computed(() => ({ param: ref.value })) so that p.value is
+ * always an object during setup — avoids `null.param` crash when Nuxt evaluates computedKey.
+ */
+function buildPathParamComposableLines(prefix, fn, pathParam) {
+    return [
+        `  const ${prefix}Ref = shallowRef(null);`,
+        `  const ${prefix}Composable = ${fn}(computed(() => ({ ${pathParam}: ${prefix}Ref.value })) as any, { immediate: false });`,
+    ];
+}
 /**
  * Build the body of the exported connector function.
  */
@@ -223,6 +250,12 @@ function buildFunctionBody(resource) {
     if (resource.updateEndpoint && resource.zodSchemas.update) {
         optionKeys.push('updateSchema');
     }
+    const hasMutations = !!(resource.createEndpoint ||
+        resource.updateEndpoint ||
+        resource.deleteEndpoint);
+    if (hasMutations) {
+        optionKeys.push('onRequest', 'onSuccess', 'onError', 'onFinish');
+    }
     const optionsDestructure = optionKeys.length > 0 ? `  const { ${optionKeys.join(', ')} } = options;\n` : '';
     // ── List / table sub-connector ─────────────────────────────────────────────
     if (resource.listEndpoint) {
@@ -243,23 +276,28 @@ function buildFunctionBody(resource) {
     }
     if (resource.detailEndpoint) {
         const fn = toAsyncDataName(resource.detailEndpoint.operationId);
-        // Wrap the composable to map the generic idRef to the actual path param name.
-        // useDetailConnector passes a ref<id> and calls refresh() after updating it.
         const pathParam = resource.detailEndpoint.pathParams[0] ?? 'id';
-        subConnectors.push(`  const detail = useDetailConnector(`, `    (idRef, opts) => ${fn}(computed(() => ({ ${pathParam}: idRef.value })) as any, opts),`, `  ) as unknown as DetailConnectorReturn<${pascal}>;`);
+        subConnectors.push(...buildPathParamComposableLines('_detail', fn, pathParam));
+        subConnectors.push(`  const detail = useDetailConnector((id: any) => { _detailRef.value = id; return _detailComposable; }) as unknown as DetailConnectorReturn<${pascal}>;`);
     }
     if (resource.createEndpoint) {
         const fn = toAsyncDataName(resource.createEndpoint.operationId);
-        const inputType = resource.zodSchemas.create ? `${pascal}CreateInput` : `Record<string, unknown>`;
+        const inputType = resource.zodSchemas.create
+            ? `${pascal}CreateInput`
+            : `Record<string, unknown>`;
         const schemaArg = resource.zodSchemas.create
             ? `{ schema: ${pascal}CreateSchema, schemaOverride: createSchema }`
             : '{}';
-        subConnectors.push(`  const createForm = useFormConnector(${fn}, ${schemaArg}) as unknown as FormConnectorReturn<${inputType}>;`);
+        subConnectors.push(`  const _createRef = shallowRef({});`);
+        subConnectors.push(`  const _createComposable = ${fn}(_createRef as any, { immediate: false, onRequest, onSuccess, onError, onFinish });`);
+        subConnectors.push(`  const createForm = useFormConnector((p: any) => { _createRef.value = p; return _createComposable; }, ${schemaArg}) as unknown as FormConnectorReturn<${inputType}>;`);
     }
     if (resource.updateEndpoint) {
         const fn = toAsyncDataName(resource.updateEndpoint.operationId);
         const hasDetail = !!resource.detailEndpoint;
-        const inputType = resource.zodSchemas.update ? `${pascal}UpdateInput` : `Record<string, unknown>`;
+        const inputType = resource.zodSchemas.update
+            ? `${pascal}UpdateInput`
+            : `Record<string, unknown>`;
         let schemaArg = '{}';
         if (resource.zodSchemas.update && hasDetail) {
             schemaArg = `{ schema: ${pascal}UpdateSchema, schemaOverride: updateSchema, loadWith: detail }`;
@@ -270,11 +308,23 @@ function buildFunctionBody(resource) {
         else if (hasDetail) {
             schemaArg = `{ loadWith: detail }`;
         }
-        subConnectors.push(`  const updateForm = useFormConnector(${fn}, ${schemaArg}) as unknown as FormConnectorReturn<${inputType}>;`);
+        subConnectors.push(`  const _updateRef = shallowRef({});`);
+        subConnectors.push(`  const _updateComposable = ${fn}(_updateRef as any, { immediate: false, onRequest, onSuccess, onError, onFinish });`);
+        subConnectors.push(`  const updateForm = useFormConnector((p: any) => { _updateRef.value = p; return _updateComposable; }, ${schemaArg}) as unknown as FormConnectorReturn<${inputType}>;`);
     }
     if (resource.deleteEndpoint) {
         const fn = toAsyncDataName(resource.deleteEndpoint.operationId);
-        subConnectors.push(`  const deleteAction = useDeleteConnector(${fn}) as unknown as DeleteConnectorReturn<${pascal}>;`);
+        const pathParam = resource.deleteEndpoint.pathParams[0];
+        if (pathParam) {
+            subConnectors.push(...buildPathParamComposableLines('_delete', fn, pathParam));
+            subConnectors.push(`  const _deleteComposableWithHooks = ${fn}(computed(() => ({ ${pathParam}: _deleteRef.value })) as any, { immediate: false, onRequest, onSuccess, onError, onFinish });`);
+            subConnectors.push(`  const deleteAction = useDeleteConnector((item: any) => { _deleteRef.value = item?.${pathParam} ?? item?.id ?? item; return _deleteComposableWithHooks; }) as unknown as DeleteConnectorReturn<${pascal}>;`);
+        }
+        else {
+            subConnectors.push(`  const _deleteRef = shallowRef({});`);
+            subConnectors.push(`  const _deleteComposable = ${fn}(_deleteRef as any, { immediate: false, onRequest, onSuccess, onError, onFinish });`);
+            subConnectors.push(`  const deleteAction = useDeleteConnector((p: any) => { _deleteRef.value = p; return _deleteComposable; }) as unknown as DeleteConnectorReturn<${pascal}>;`);
+        }
     }
     // Return object — always includes table (undefined when no list + no factory)
     const returnKeys = ['table'];

package/dist/generators/components/schema-analyzer/intent-detector.js

@@ -36,13 +36,6 @@ function getSuccessResponseSchema(operation) {
 function isArraySchema(schema) {
     return schema.type === 'array' || schema.items !== undefined;
 }
-/** True when schema is a primitive scalar (string, number, integer, boolean) — not a resource */
-function isPrimitiveSchema(schema) {
-    return (schema.type === 'string' ||
-        schema.type === 'number' ||
-        schema.type === 'integer' ||
-        schema.type === 'boolean');
-}
 // ─── Request body schema ──────────────────────────────────────────────────────
 function getRequestBodySchema(operation) {
     if (!operation.requestBody?.content) {
@@ -91,11 +84,6 @@ export function detectIntent(method, path, operation) {
             if (isArraySchema(responseSchema)) {
                 return 'list';
             }
-            // Primitive response (string, number, boolean) → not a CRUD resource
-            // e.g. GET /user/login returns a string token — not a list or detail
-            if (isPrimitiveSchema(responseSchema)) {
-                return 'unknown';
-            }
             // Object response — distinguish list vs detail by path structure:
             //   GET /pets/{id}  → has path param → detail (single item fetch)
             //   GET /pets       → no path param  → list (likely paginated envelope: { data: [], total: n })
@@ -134,6 +122,7 @@ export function extractEndpoints(path, pathItem) {
             intent,
             hasPathParams: pathParams.length > 0,
             pathParams,
+            hasQueryParams: (operation.parameters ?? []).some((p) => p.in === 'query'),
         };
         // Attach response schema for GET intents
         if (method === 'GET') {

package/dist/generators/components/schema-analyzer/openapi-reader.js

@@ -39,7 +39,16 @@ function resolveRefs(node, root, visited = new Set()) {
         const resolved = resolvePointer(root, ref);
         const newVisited = new Set(visited);
         newVisited.add(ref);
-        return resolveRefs(resolved, root, newVisited);
+        const resolvedFull = resolveRefs(resolved, root, newVisited);
+        // Annotate resolved schemas from #/components/schemas/Xxx with the original
+        // component name so downstream consumers can recover the model type name.
+        if (typeof resolvedFull === 'object' &&
+            resolvedFull !== null &&
+            ref.startsWith('#/components/schemas/')) {
+            const refName = ref.split('/').pop();
+            return { ...resolvedFull, 'x-ref-name': refName };
+        }
+        return resolvedFull;
     }
     const result = {};
     for (const [key, value] of Object.entries(obj)) {

package/dist/generators/components/schema-analyzer/resource-grouper.js

@@ -85,10 +85,17 @@ export function buildResourceMap(spec) {
             ? buildZodSchema(updateEp.requestBodySchema)
             : undefined;
         const resourceName = pascalCase(tag);
+        // Infer the SDK model type name from the original $ref component name.
+        // Priority: detail response > list items > list response (may be envelope object).
+        const itemTypeName = detailEp?.responseSchema?.['x-ref-name'] ??
+            listEp?.responseSchema?.items?.['x-ref-name'] ??
+            listEp?.responseSchema?.['x-ref-name'] ??
+            undefined;
         const info = {
             name: resourceName,
             tag,
             composableName: toConnectorName(tag),
+            itemTypeName,
             endpoints,
             listEndpoint: listEp,
             detailEndpoint: detailEp,

package/dist/generators/components/schema-analyzer/schema-field-mapper.js

@@ -132,7 +132,7 @@ function baseZodExpr(prop) {
         case 'array':
             return arrayZodExpr(prop);
         case 'object':
-            return objectZodExpr(prop);
+            return 'z.record(z.string(), z.unknown())';
         default:
             // $ref already resolved, unknown type → permissive
             return 'z.unknown()';
@@ -181,27 +181,6 @@ function numberZodExpr(prop) {
     }
     return expr;
 }
-function objectZodExpr(prop) {
-    const { additionalProperties } = prop;
-    // additionalProperties: false or undefined → plain object
-    if (!additionalProperties || additionalProperties === true) {
-        return 'z.record(z.unknown())';
-    }
-    // additionalProperties has a known primitive type → typed record
-    const valueExpr = additionalPropsZodExpr(additionalProperties);
-    return `z.record(${valueExpr})`;
-}
-function additionalPropsZodExpr(schema) {
-    switch (schema.type) {
-        case 'string': return stringZodExpr(schema);
-        case 'integer': return integerZodExpr(schema);
-        case 'number': return numberZodExpr(schema);
-        case 'boolean': return 'z.boolean()';
-        case 'array': return arrayZodExpr(schema);
-        case 'object': return objectZodExpr(schema);
-        default: return 'z.unknown()';
-    }
-}
 function arrayZodExpr(prop) {
     const itemExpr = prop.items ? baseZodExpr(prop.items) : 'z.unknown()';
     let expr = `z.array(${itemExpr})`;

package/dist/generators/components/schema-analyzer/types.d.ts

@@ -27,6 +27,8 @@ export interface OpenApiPropertySchema {
     allOf?: OpenApiPropertySchema[];
     oneOf?: OpenApiPropertySchema[];
     anyOf?: OpenApiPropertySchema[];
+    /** Injected by the $ref resolver — original component schema name, e.g. 'Pet' */
+    'x-ref-name'?: string;
 }
 export interface OpenApiSchema extends OpenApiPropertySchema {
     required?: string[];
@@ -96,6 +98,8 @@ export interface EndpointInfo {
     responseSchema?: OpenApiSchema;
     hasPathParams: boolean;
     pathParams: string[];
+    /** True when the operation has at least one query parameter */
+    hasQueryParams: boolean;
 }
 export type FieldType = 'input' | 'textarea' | 'select' | 'checkbox' | 'datepicker' | 'number';
 export interface FormFieldDef {
@@ -136,6 +140,12 @@ export interface ResourceInfo {
     updateEndpoint?: EndpointInfo;
     /** The one endpoint detected as delete (DELETE) */
     deleteEndpoint?: EndpointInfo;
+    /**
+     * Inferred item model type name (e.g. 'Pet', 'Order') derived from the
+     * response schema's original $ref component name. Used for SDK type imports.
+     * Undefined when the response type is anonymous/primitive.
+     */
+    itemTypeName?: string;
     /** Columns inferred from the list/detail response schema */
     columns: ColumnDef[];
     /** Form fields inferred from the request body schema */

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

@@ -0,0 +1,12 @@
+import type { ConnectorGeneratorOptions } from './types.js';
+import { type Logger } from '../../cli/logger.js';
+/**
+ * Generate headless connector composables from an OpenAPI spec.
+ *
+ * Steps:
+ *  1. Analyze the spec → ResourceMap (Schema Analyzer)
+ *  2. For each resource: generate connector source, format, write
+ *  3. Write an index barrel file
+ *  4. Copy runtime helpers to the user's project
+ */
+export declare function generateConnectors(options: ConnectorGeneratorOptions, logger?: Logger): Promise<void>;

package/dist/generators/connectors/generator.js

@@ -0,0 +1,115 @@
+import * as path from 'path';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+import { format } from 'prettier';
+import { analyzeSpec } from '../components/schema-analyzer/index.js';
+import { generateConnectorFile, connectorFileName, generateConnectorIndexFile, } from './templates.js';
+import { createClackLogger } from '../../cli/logger.js';
+// Runtime files that must be copied to the user's project
+const RUNTIME_FILES = [
+    'connector-types.ts',
+    'useGetAllConnector.ts',
+    'useGetConnector.ts',
+    'useCreateConnector.ts',
+    'useUpdateConnector.ts',
+    'useDeleteConnector.ts',
+    'zod-error-merger.ts',
+];
+/**
+ * Format TypeScript source with Prettier.
+ * Falls back to unformatted code on error.
+ */
+async function formatCode(code, logger) {
+    try {
+        return await format(code, { parser: 'typescript' });
+    }
+    catch (error) {
+        logger.log.warn(`Prettier formatting failed: ${String(error)}`);
+        return code;
+    }
+}
+/**
+ * Generate headless connector composables from an OpenAPI spec.
+ *
+ * Steps:
+ *  1. Analyze the spec → ResourceMap (Schema Analyzer)
+ *  2. For each resource: generate connector source, format, write
+ *  3. Write an index barrel file
+ *  4. Copy runtime helpers to the user's project
+ */
+export async function generateConnectors(options, logger = createClackLogger()) {
+    const spinner = logger.spinner();
+    const outputDir = path.resolve(options.outputDir);
+    const composablesRelDir = options.composablesRelDir ?? '../use-async-data';
+    const runtimeRelDir = options.runtimeRelDir ?? '../runtime';
+    // ── 1. Analyze spec ───────────────────────────────────────────────────────
+    spinner.start('Analyzing OpenAPI spec');
+    const resourceMap = analyzeSpec(options.inputSpec);
+    spinner.stop(`Found ${resourceMap.size} resource(s)`);
+    if (resourceMap.size === 0) {
+        logger.log.warn('No resources found in spec — nothing to generate');
+        return;
+    }
+    // ── 2. Prepare output directory ───────────────────────────────────────────
+    // emptyDir (not ensureDir) so stale connectors from previous runs are removed.
+    spinner.start('Preparing output directory');
+    await fs.emptyDir(outputDir);
+    spinner.stop('Output directory ready');
+    // ── 3. Generate connector files ───────────────────────────────────────────
+    spinner.start('Generating connector composables');
+    let successCount = 0;
+    let errorCount = 0;
+    const generatedNames = [];
+    for (const resource of resourceMap.values()) {
+        try {
+            const code = generateConnectorFile(resource, composablesRelDir, '../..', runtimeRelDir);
+            const formatted = await formatCode(code, logger);
+            const fileName = connectorFileName(resource.composableName);
+            const filePath = path.join(outputDir, fileName);
+            await fs.writeFile(filePath, formatted, 'utf-8');
+            generatedNames.push(resource.composableName);
+            successCount++;
+        }
+        catch (error) {
+            logger.log.error(`Error generating ${resource.composableName}: ${String(error)}`);
+            errorCount++;
+        }
+    }
+    spinner.stop(`Generated ${successCount} connector(s)`);
+    // ── 4. Write barrel index ─────────────────────────────────────────────────
+    if (generatedNames.length > 0) {
+        try {
+            const indexCode = generateConnectorIndexFile(generatedNames);
+            const formattedIndex = await formatCode(indexCode, logger);
+            await fs.writeFile(path.join(outputDir, 'index.ts'), formattedIndex, 'utf-8');
+        }
+        catch (error) {
+            logger.log.warn(`Could not write connector index: ${String(error)}`);
+        }
+    }
+    // ── 5. Copy runtime helpers ───────────────────────────────────────────────
+    // Runtime files live in src/ and must be physical .ts files in the user's project
+    // so Nuxt/Vite can type-check them.
+    //
+    // Path resolution trick:
+    //   •  During development (ts-node / tsx):  __dirname ≈ src/generators/connectors/
+    //   •  After `tsc` build:                   __dirname ≈ dist/generators/connectors/
+    //
+    // In both cases we step up 3 levels and re-enter src/ to find the runtime sources.
+    spinner.start('Copying runtime files');
+    const runtimeDir = path.resolve(outputDir, runtimeRelDir);
+    await fs.ensureDir(runtimeDir); // ensureDir — other runtime files may live here too
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const runtimeSrcDir = path.resolve(__dirname, '../../../src/generators/connectors/runtime');
+    for (const file of RUNTIME_FILES) {
+        const src = path.join(runtimeSrcDir, file);
+        const dest = path.join(runtimeDir, file);
+        await fs.copyFile(src, dest);
+    }
+    spinner.stop('Runtime files copied');
+    // ── 6. Summary ────────────────────────────────────────────────────────────
+    if (errorCount > 0) {
+        logger.log.warn(`Completed with ${errorCount} error(s)`);
+    }
+    logger.log.success(`Generated ${successCount} connector(s) in ${outputDir}`);
+}

package/dist/generators/connectors/runtime/connector-types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * connector-types.ts — Structural return type interfaces for the new connector system.
+ *
+ * Uses locally-defined minimal type aliases for Ref/ComputedRef so this file compiles
+ * in the CLI context (where Vue is not installed) and remains structurally compatible
+ * with Vue's actual types in the user's Nuxt project.
+ *
+ * Copied to the user's project alongside the generated connectors and runtime helpers.
+ */
+type Ref<T> = {
+    value: T;
+};
+type ComputedRef<T> = {
+    readonly value: T;
+};
+/** Operation name passed as context to connector-level callbacks. */
+export type ConnectorOperation = 'create' | 'update' | 'delete' | 'get' | 'getAll';
+export interface ConnectorCallbackContext {
+    operation: ConnectorOperation;
+}
+export interface ColumnDef {
+    key: string;
+    label: string;
+    type: string;
+}
+export interface FormFieldDef {
+    key: string;
+    label: string;
+    type: string;
+    required: boolean;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    placeholder?: string;
+    hidden?: boolean;
+}
+export interface PaginationState {
+    currentPage: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    setPerPage: (n: number) => void;
+}
+export interface ConnectorUi {
+    isOpen: Ref<boolean>;
+    open: (...args: any[]) => void;
+    close: () => void;
+}
+export interface GetAllConnectorReturn<TRow = unknown> {
+    items: ComputedRef<TRow[]>;
+    columns: ComputedRef<ColumnDef[]>;
+    loading: ComputedRef<boolean>;
+    error: ComputedRef<unknown>;
+    pagination: ComputedRef<PaginationState | null>;
+    goToPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    setPerPage: (n: number) => void;
+    selected: Ref<TRow[]>;
+    select: (item: TRow) => void;
+    deselect: (item: TRow) => void;
+    toggleSelect: (item: TRow) => void;
+    clearSelection: () => void;
+    load: (params?: unknown) => Promise<void>;
+    onSuccess: Ref<((items: TRow[]) => void) | null>;
+    onError: Ref<((err: unknown) => void) | null>;
+}
+export interface GetConnectorReturn<TItem = unknown> {
+    data: Ref<TItem | null>;
+    loading: Ref<boolean>;
+    error: Ref<unknown>;
+    fields: ComputedRef<FormFieldDef[]>;
+    load: (id: string | number) => Promise<TItem>;
+    clear: () => void;
+    onSuccess: (fn: (item: TItem) => void) => void;
+    onError: (fn: (err: unknown) => void) => void;
+}
+export interface CreateConnectorReturn<TInput = Record<string, unknown>, TOutput = TInput> {
+    model: Ref<Partial<TInput>>;
+    errors: Ref<Record<string, string[]>>;
+    loading: Ref<boolean>;
+    error: Ref<unknown>;
+    submitted: Ref<boolean>;
+    isValid: ComputedRef<boolean>;
+    hasErrors: ComputedRef<boolean>;
+    fields: ComputedRef<FormFieldDef[]>;
+    execute: (data?: Partial<TInput>) => Promise<TOutput | undefined>;
+    refresh: (data?: Partial<TInput>) => Promise<TOutput | undefined>;
+    reset: () => void;
+    setValues: (data: Partial<TInput>) => void;
+    setField: (key: keyof TInput, value: unknown) => void;
+    onSuccess: (fn: (data: TOutput) => void) => void;
+    onError: (fn: (err: unknown) => void) => void;
+    ui: {
+        isOpen: Ref<boolean>;
+        open: () => void;
+        close: () => void;
+    };
+}
+export interface UpdateConnectorReturn<TInput = Record<string, unknown>, TOutput = TInput> {
+    model: Ref<Partial<TInput>>;
+    errors: Ref<Record<string, string[]>>;
+    loading: Ref<boolean>;
+    error: Ref<unknown>;
+    submitted: Ref<boolean>;
+    isValid: ComputedRef<boolean>;
+    hasErrors: ComputedRef<boolean>;
+    fields: ComputedRef<FormFieldDef[]>;
+    targetId: Ref<string | number | null>;
+    load: (id: string | number) => Promise<void>;
+    execute: (id: string | number, data?: Partial<TInput>) => Promise<TOutput | undefined>;
+    refresh: (id: string | number, data?: Partial<TInput>) => Promise<TOutput | undefined>;
+    reset: () => void;
+    setValues: (data: Partial<TInput>) => void;
+    setField: (key: keyof TInput, value: unknown) => void;
+    onSuccess: (fn: (data: TOutput) => void) => void;
+    onError: (fn: (err: unknown) => void) => void;
+    ui: {
+        isOpen: Ref<boolean>;
+        open: (item?: Partial<TInput> & Record<string, unknown>) => void;
+        close: () => void;
+    };
+}
+export interface DeleteConnectorReturn<TItem = unknown> {
+    staged: Ref<TItem | null>;
+    hasStaged: ComputedRef<boolean>;
+    loading: Ref<boolean>;
+    error: Ref<unknown>;
+    stage: (item: TItem) => void;
+    cancel: () => void;
+    execute: (item?: TItem) => Promise<void>;
+    refresh: (item?: TItem) => Promise<void>;
+    onSuccess: (fn: (item: TItem) => void) => void;
+    onError: (fn: (err: unknown) => void) => void;
+    ui: {
+        isOpen: Ref<boolean>;
+        open: (item: TItem) => void;
+        close: () => void;
+    };
+}
+export {};

package/dist/generators/connectors/runtime/connector-types.js

@@ -0,0 +1,10 @@
+/**
+ * connector-types.ts — Structural return type interfaces for the new connector system.
+ *
+ * Uses locally-defined minimal type aliases for Ref/ComputedRef so this file compiles
+ * in the CLI context (where Vue is not installed) and remains structurally compatible
+ * with Vue's actual types in the user's Nuxt project.
+ *
+ * Copied to the user's project alongside the generated connectors and runtime helpers.
+ */
+export {};

package/dist/generators/connectors/runtime/useCreateConnector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param url     The endpoint URL string. e.g. '/pet'
+ * @param options Configuration: schema, fields, method, baseURL, callbacks, etc.
+ */
+export declare function useCreateConnector(url: any, options?: {}): {
+    model: any;
+    errors: any;
+    loading: any;
+    error: any;
+    submitted: any;
+    isValid: any;
+    hasErrors: any;
+    fields: any;
+    execute: (data: any) => Promise<any>;
+    refresh: (data: any) => Promise<any>;
+    reset: () => void;
+    setValues: (data: any) => void;
+    setField: (key: any, value: any) => void;
+    onSuccess: (fn: any) => void;
+    onError: (fn: any) => void;
+    ui: {
+        isOpen: any;
+        open(): void;
+        close(): void;
+    };
+};