@codewithagents/openapi-react-query 3.5.1 → 3.5.2

package/src/__tests__/hooks.test.ts

@@ -1,1845 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { OpenAPIV3_1 } from 'openapi-types'
-import { generateHooks } from '../plugins/hooks.js'
-
-// Load fixture directly (no parseSpec — avoids needing openapi-gen dist built)
-const fixturePath = join(import.meta.dirname, '../../__fixtures__/specs/task-hooks.json')
-const spec = JSON.parse(readFileSync(fixturePath, 'utf-8')) as OpenAPIV3_1.Document
-
-const { filename, content } = generateHooks(spec, { staleTime: 30_000, gcTime: 300_000 })
-
-describe('generateHooks — task-hooks.json fixture', () => {
-  it('filename is hooks.ts', () => {
-    expect(filename).toBe('hooks.ts')
-  })
-
-  it('contains auto-generated header comment', () => {
-    expect(content).toContain(
-      '// This file is auto-generated by @codewithagents/openapi-react-query — do not edit'
-    )
-  })
-
-  it('imports useQuery and useMutation from @tanstack/react-query', () => {
-    expect(content).toContain("from '@tanstack/react-query'")
-    expect(content).toContain('useQuery')
-    expect(content).toContain('useMutation')
-  })
-
-  it('imports all client functions and ApiError from ./client.js', () => {
-    expect(content).toContain("from './client.js'")
-    expect(content).toContain('listTasks')
-    expect(content).toContain('getTask')
-    expect(content).toContain('createTask')
-    expect(content).toContain('updateTask')
-    expect(content).toContain('deleteTask')
-    expect(content).toContain('type ApiError')
-  })
-
-  it('generates taskKeys factory with all(), list(), and detail() entries', () => {
-    expect(content).toContain('export const taskKeys')
-    expect(content).toContain("all: () => ['tasks'] as const")
-    expect(content).toContain('list:')
-    expect(content).toContain('detail:')
-  })
-
-  it('useListTasks uses taskKeys.list(params) as queryKey', () => {
-    expect(content).toContain('useListTasks')
-    expect(content).toContain('queryKey: taskKeys.list(params)')
-  })
-
-  it('useListTasks has staleTime: 30_000', () => {
-    expect(content).toContain('staleTime: 30000,')
-  })
-
-  it('useListTasks has gcTime: 300_000', () => {
-    expect(content).toContain('gcTime: 300000,')
-  })
-
-  it('useGetTask accepts id as positional arg and uses taskKeys.detail(id!)', () => {
-    expect(content).toContain('useGetTask')
-    expect(content).toContain('id: string | undefined | null')
-    expect(content).toContain('queryKey: taskKeys.detail(id!)')
-  })
-
-  it('useCreateTask variables type is Parameters<typeof createTask>[0]', () => {
-    expect(content).toContain('useCreateTask')
-    expect(content).toContain('Parameters<typeof createTask>[0]')
-  })
-
-  it('useUpdateTask variables type has { id: string; body: Parameters<typeof updateTask>[1] }', () => {
-    expect(content).toContain('useUpdateTask')
-    expect(content).toContain('{ id: string; body: Parameters<typeof updateTask>[1] }')
-  })
-
-  it('useUpdateTask mutationFn destructures { id, body }', () => {
-    expect(content).toContain('({ id, body }) => updateTask(id, body)')
-  })
-
-  it('useDeleteTask variables type is string', () => {
-    // deleteTask has one path param and no body → variables type is string
-    expect(content).toContain('useDeleteTask')
-    // The mutation signature should include 'string' as variables type for deleteTask
-    // We check that the mutationFn destructures id directly
-    expect(content).toContain('(id) => deleteTask(id)')
-  })
-
-  it('useDeleteTask mutationFn is (id) => deleteTask(id)', () => {
-    expect(content).toContain('mutationFn: (id) => deleteTask(id)')
-  })
-
-  it('staleTime and gcTime are overridable via options spread', () => {
-    // ...options must appear AFTER staleTime and gcTime in the useQuery call
-    const staleTimeIdx = content.indexOf('staleTime: 30000,')
-    const gcTimeIdx = content.indexOf('gcTime: 300000,')
-    const spreadIdx = content.indexOf('...options,', gcTimeIdx)
-    expect(staleTimeIdx).toBeGreaterThan(-1)
-    expect(gcTimeIdx).toBeGreaterThan(staleTimeIdx)
-    expect(spreadIdx).toBeGreaterThan(gcTimeIdx)
-  })
-})
-
-// ── Feature #61: Auto-disable detail hooks when path param is nullish ─────────
-
-describe('generateHooks — Feature #61: nullish path params auto-disable', () => {
-  it('useGetTask signature contains string | undefined | null for id', () => {
-    expect(content).toContain('id: string | undefined | null')
-  })
-
-  it('useGetTask generated hook contains enabled: id != null guard', () => {
-    expect(content).toContain('enabled: id != null && (options?.enabled ?? true)')
-  })
-
-  it('enabled guard comes before ...options spread', () => {
-    const enabledIdx = content.indexOf('enabled: id != null')
-    const spreadIdx = content.indexOf('...options,', enabledIdx)
-    expect(enabledIdx).toBeGreaterThan(-1)
-    expect(spreadIdx).toBeGreaterThan(enabledIdx)
-  })
-
-  it('hooks without path params do NOT have an enabled guard', () => {
-    // useListTasks has no path params — should not generate an enabled guard
-    const listHookStart = content.indexOf('export function useListTasks')
-    const listHookEnd = content.indexOf('\n}', listHookStart) + 2
-    const listHookContent = content.slice(listHookStart, listHookEnd)
-    expect(listHookContent).not.toContain('enabled:')
-  })
-
-  it('multiple path params generate AND-chained enabled guard', () => {
-    const specMultiParam: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/items/{projectId}/{id}': {
-          get: {
-            operationId: 'getItem',
-            parameters: [
-              { name: 'projectId', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content: c } = generateHooks(specMultiParam, { staleTime: 0, gcTime: 0 })
-    expect(c).toContain('projectId: string | undefined | null')
-    expect(c).toContain('id: string | undefined | null')
-    expect(c).toContain('enabled: projectId != null && id != null && (options?.enabled ?? true)')
-  })
-})
-
-// ── Bug #1: Params optionality ──────────────────────────────────────────────────
-
-describe('generateHooks — Bug #52: params optionality based on required query params', () => {
-  // Spec with a required query param
-  const specWithRequiredQueryParam: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/templates': {
-        get: {
-          operationId: 'listTemplates',
-          parameters: [
-            { name: 'platform', in: 'query', required: true, schema: { type: 'string' } },
-            { name: 'page', in: 'query', schema: { type: 'integer' } },
-          ],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  // Spec with only optional query params
-  const specWithOptionalQueryParams: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/templates': {
-        get: {
-          operationId: 'listTemplates',
-          parameters: [
-            { name: 'page', in: 'query', schema: { type: 'integer' } },
-            { name: 'size', in: 'query', schema: { type: 'integer' } },
-          ],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  it('hook marks params as required when any query param has required: true', () => {
-    const { content } = generateHooks(specWithRequiredQueryParam, { staleTime: 0, gcTime: 0 })
-    // params should NOT be optional (no ?)
-    expect(content).toContain('params: Parameters<typeof listTemplates>')
-    expect(content).not.toContain('params?: Parameters<typeof listTemplates>')
-  })
-
-  it('key factory marks params as required when any query param has required: true', () => {
-    const { content } = generateHooks(specWithRequiredQueryParam, { staleTime: 0, gcTime: 0 })
-    // key factory list entry should have required params
-    expect(content).toContain('params: Parameters<typeof listTemplates>[0]')
-    expect(content).not.toContain('params?: Parameters<typeof listTemplates>[0]')
-  })
-
-  it('hook marks params as optional when all query params are optional', () => {
-    const { content } = generateHooks(specWithOptionalQueryParams, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('params?: Parameters<typeof listTemplates>')
-  })
-
-  it('key factory marks params as optional when all query params are optional', () => {
-    const { content } = generateHooks(specWithOptionalQueryParams, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('params?: Parameters<typeof listTemplates>[0]')
-  })
-})
-
-// ── Bug #2: Key factory missing query params for multi-arg endpoints ────────────
-
-describe('generateHooks — Bug #53: key factory includes query params when operation has both path and query params', () => {
-  const specWithPathAndQueryParams: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/templates/{uuid}': {
-        get: {
-          operationId: 'readTemplateDetails',
-          parameters: [
-            { name: 'uuid', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'platform', in: 'query', schema: { type: 'string' } },
-          ],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  const specWithPathAndRequiredQueryParams: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/reports/{id}': {
-        get: {
-          operationId: 'getReport',
-          parameters: [
-            { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'format', in: 'query', required: true, schema: { type: 'string' } },
-          ],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  it('key factory detail entry includes optional params when path + optional query params', () => {
-    const { content } = generateHooks(specWithPathAndQueryParams, { staleTime: 0, gcTime: 0 })
-    // Key factory should accept (uuid: string, params?)
-    expect(content).toContain('(uuid: string, params?: Parameters<typeof readTemplateDetails>[1])')
-  })
-
-  it('key factory detail entry includes params value in tuple', () => {
-    const { content } = generateHooks(specWithPathAndQueryParams, { staleTime: 0, gcTime: 0 })
-    // Key tuple should include params
-    expect(content).toContain("['templates', uuid, params]")
-  })
-
-  it('hook calls key factory with both path and query params', () => {
-    const { content } = generateHooks(specWithPathAndQueryParams, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('templateKeys.detail(uuid!, params)')
-  })
-
-  it('key factory detail entry includes required params when path + required query params', () => {
-    const { content } = generateHooks(specWithPathAndRequiredQueryParams, {
-      staleTime: 0,
-      gcTime: 0,
-    })
-    // Key factory should accept required params (no ?)
-    expect(content).toContain('(id: string, params: Parameters<typeof getReport>[1])')
-  })
-
-  it('hook marks params as required when path param + required query param', () => {
-    const { content } = generateHooks(specWithPathAndRequiredQueryParams, {
-      staleTime: 0,
-      gcTime: 0,
-    })
-    expect(content).toContain('params: Parameters<typeof getReport>[1]')
-    expect(content).not.toContain('params?: Parameters<typeof getReport>[1]')
-  })
-})
-
-// ── Bug #3: Mutation hook argument shapes ───────────────────────────────────────
-
-describe('generateHooks — Bug #54: mutation hook handles all argument shapes', () => {
-  const makeSpec = (
-    pathSegment: string,
-    method: string,
-    hasBody: boolean,
-    queryParams: Array<{ name: string; required?: boolean }>
-  ): OpenAPIV3_1.Document => ({
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      [pathSegment]: {
-        [method]: {
-          operationId: `${method}Op`,
-          parameters: queryParams.map((p) => ({
-            name: p.name,
-            in: 'query' as const,
-            required: p.required,
-            schema: { type: 'string' as const },
-          })),
-          ...(hasBody
-            ? {
-                requestBody: {
-                  required: true,
-                  content: {
-                    'application/json': { schema: { $ref: '#/components/schemas/Body' } },
-                  },
-                },
-              }
-            : {}),
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-    components: {
-      schemas: {
-        Body: { type: 'object' as const, properties: { name: { type: 'string' as const } } },
-      },
-    },
-  })
-
-  it('mutation with query params only (no body, no path): variables type is Parameters[0], mutationFn is (vars) => fn(vars)', () => {
-    const spec = makeSpec('/resources', 'post', false, [{ name: 'filter', required: false }])
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // Variables type should be Parameters<typeof postOp>[0]
-    expect(content).toContain('Parameters<typeof postOp>[0]')
-    // mutationFn should pass vars through
-    expect(content).toContain('(vars) => postOp(vars)')
-  })
-
-  it('mutation with body + query params (no path): variables is { body, params }, mutationFn destructures', () => {
-    const spec = makeSpec('/resources', 'post', true, [{ name: 'dryRun', required: false }])
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // Variables type includes both body and params
-    expect(content).toContain('body: Parameters<typeof postOp>[0]')
-    expect(content).toContain('params: Parameters<typeof postOp>[1]')
-    // mutationFn destructures and passes both
-    expect(content).toContain('({ body, params }) => postOp(body, params)')
-  })
-
-  it('mutation with path + body + query params: variables is { id, body, params }, mutationFn destructures all', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/resources/{id}': {
-          patch: {
-            operationId: 'patchOp',
-            parameters: [
-              { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'dryRun', in: 'query', schema: { type: 'string' } },
-            ],
-            requestBody: {
-              required: true,
-              content: { 'application/json': { schema: { $ref: '#/components/schemas/Body' } } },
-            },
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-      components: {
-        schemas: { Body: { type: 'object', properties: { name: { type: 'string' } } } },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // Variables includes id, body, and params
-    expect(content).toContain('id: string')
-    expect(content).toContain('body: Parameters<typeof patchOp>[1]')
-    expect(content).toContain('params: Parameters<typeof patchOp>[2]')
-    // mutationFn destructures all three and passes in correct order
-    expect(content).toContain('({ id, body, params }) => patchOp(id, body, params)')
-  })
-
-  it('mutation with path + query params only (no body): variables is { id, params }, mutationFn uses both', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/resources/{id}': {
-          delete: {
-            operationId: 'deleteOp',
-            parameters: [
-              { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'cascade', in: 'query', schema: { type: 'string' } },
-            ],
-            responses: { '204': { description: 'deleted' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // Variables includes id and params
-    expect(content).toContain('id: string')
-    expect(content).toContain('params: Parameters<typeof deleteOp>[1]')
-    // mutationFn destructures and passes both
-    expect(content).toContain('({ id, params }) => deleteOp(id, params)')
-  })
-
-  it('existing body-only mutation still works: variables is Parameters[0], mutationFn is (vars) => fn(vars)', () => {
-    // Regression: existing behavior must be preserved
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/tasks': {
-          post: {
-            operationId: 'createTask',
-            requestBody: {
-              required: true,
-              content: {
-                'application/json': { schema: { $ref: '#/components/schemas/CreateTask' } },
-              },
-            },
-            responses: { '201': { description: 'created' } },
-          },
-        },
-      },
-      components: {
-        schemas: { CreateTask: { type: 'object', properties: { title: { type: 'string' } } } },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('Parameters<typeof createTask>[0]')
-    expect(content).toContain('(vars) => createTask(vars)')
-  })
-})
-
-describe('generateHooks — tag name to camelCase key factory', () => {
-  // Resource name comes from the path segment, not the tag — use tag name as path to test conversion
-  const makeSpec = (pathSegment: string): OpenAPIV3_1.Document => ({
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      [`/${pathSegment}`]: {
-        get: {
-          operationId: `list${pathSegment}`,
-          responses: {
-            '200': {
-              description: 'ok',
-              content: {
-                'application/json': { schema: { type: 'array', items: { type: 'object' } } },
-              },
-            },
-          },
-        },
-      },
-    },
-  })
-
-  it('kebab-case path /page-selections → pageSelectionKeys (valid JS identifier)', () => {
-    const { content } = generateHooks(makeSpec('page-selections'), { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('export const pageSelectionKeys')
-    expect(content).not.toContain('page-selectionKeys')
-  })
-
-  it('snake_case path /group_reservations → groupReservationKeys', () => {
-    const { content } = generateHooks(makeSpec('group_reservations'), { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('export const groupReservationKeys')
-    expect(content).not.toContain('group_reservationKeys')
-  })
-
-  it('plain path /tasks → taskKeys (unchanged)', () => {
-    const { content } = generateHooks(makeSpec('tasks'), { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('export const taskKeys')
-  })
-
-  it('kebab-case path /ad-settings → adSettingKeys', () => {
-    const { content } = generateHooks(makeSpec('ad-settings'), { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('export const adSettingKeys')
-    expect(content).not.toContain('ad-settingKeys')
-  })
-})
-
-// ── Feature #60: useSuspenseQuery variants ─────────────────────────────────────
-
-describe('generateHooks — Feature #60: suspense query variants', () => {
-  const suspenseSpec: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/api/v1/tasks': {
-        get: {
-          operationId: 'listTasks',
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/api/v1/tasks/{id}': {
-        get: {
-          operationId: 'getTask',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  it('when suspense: true, output contains useSuspenseGetTask', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('export function useSuspenseGetTask')
-  })
-
-  it('when suspense: true, output contains useSuspenseListTasks', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('export function useSuspenseListTasks')
-  })
-
-  it('when suspense: true, output imports useSuspenseQuery from @tanstack/react-query', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('useSuspenseQuery')
-    expect(content).toContain("from '@tanstack/react-query'")
-  })
-
-  it('when suspense: true, output imports UseSuspenseQueryOptions type', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('type UseSuspenseQueryOptions')
-  })
-
-  it('suspense variant uses useSuspenseQuery call', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('return useSuspenseQuery<')
-  })
-
-  it('suspense detail hook path params are required string (not nullish)', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: true })
-    // useSuspenseGetTask should have id: string (not string | undefined | null)
-    const suspenseHookStart = content.indexOf('export function useSuspenseGetTask')
-    const suspenseHookEnd = content.indexOf('\n}', suspenseHookStart) + 2
-    const suspenseHookContent = content.slice(suspenseHookStart, suspenseHookEnd)
-    expect(suspenseHookContent).toContain('id: string')
-    expect(suspenseHookContent).not.toContain('id: string | undefined | null')
-  })
-
-  it('when suspense: false (default), no useSuspense* hooks generated', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0 })
-    expect(content).not.toContain('useSuspenseGetTask')
-    expect(content).not.toContain('useSuspenseListTasks')
-    expect(content).not.toContain('useSuspenseQuery')
-  })
-
-  it('when suspense: false explicitly, no useSuspense* hooks generated', () => {
-    const { content } = generateHooks(suspenseSpec, { staleTime: 0, gcTime: 0, suspense: false })
-    expect(content).not.toContain('useSuspenseQuery')
-  })
-
-  it('suspense hook with 1 path param + optional query param generates params? signature', () => {
-    // Covers the `pathParams.length === 1 && hasQueryParams` branch (hooks.ts line 309-310)
-    // and the `paramsRequired === false` (false) branch at line 296 → paramsToken = 'params?'
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/repos/{repoId}/commits': {
-          get: {
-            operationId: 'listRepoCommits',
-            parameters: [
-              { name: 'repoId', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'branch', in: 'query', required: false, schema: { type: 'string' } },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('export function useSuspenseListRepoCommits')
-    expect(content).toContain('repoId: string')
-    expect(content).toContain('params?:')
-  })
-
-  it('suspense hook with 1 path param + required query param generates params (non-optional) signature', () => {
-    // Covers the `paramsRequired === true` (true) branch at line 296 → paramsToken = 'params'
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/search/{category}': {
-          get: {
-            operationId: 'searchCategory',
-            parameters: [
-              { name: 'category', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'q', in: 'query', required: true, schema: { type: 'string' } },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('export function useSuspenseSearchCategory')
-    expect(content).toContain('category: string')
-    // Required query param → non-optional params token (no ?)
-    expect(content).toContain('params: Parameters')
-  })
-
-  it('suspense hook with 2 path params builds multi-param queryKey call', () => {
-    // Covers the multi-path-param (pathParams.length > 1) queryKey branch in suspense generation
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/orgs/{orgId}/repos/{repoId}': {
-          get: {
-            operationId: 'getOrgRepo',
-            parameters: [
-              { name: 'orgId', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'repoId', in: 'path', required: true, schema: { type: 'string' } },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('export function useSuspenseGetOrgRepo')
-    // Both path params appear in the function signature
-    expect(content).toContain('orgId: string')
-    expect(content).toContain('repoId: string')
-  })
-
-  it('suspense hook with 2 path params + query params builds correct queryKey', () => {
-    // Covers the else branch: pathParams.length > 1 && hasQueryParams
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/orgs/{orgId}/repos/{repoId}/commits': {
-          get: {
-            operationId: 'listOrgRepoCommits',
-            parameters: [
-              { name: 'orgId', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'repoId', in: 'path', required: true, schema: { type: 'string' } },
-              { name: 'branch', in: 'query', required: false, schema: { type: 'string' } },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0, suspense: true })
-    expect(content).toContain('export function useSuspenseListOrgRepoCommits')
-    expect(content).toContain('orgId: string')
-    expect(content).toContain('repoId: string')
-    expect(content).toContain('params?:')
-  })
-
-  it('deprecated GET with suspense: true emits @deprecated JSDoc on the suspense hook', () => {
-    // Covers the `if (op.deprecated)` branch in suspense hook generation
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/legacy': {
-          get: {
-            operationId: 'listLegacy',
-            deprecated: true,
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0, suspense: true })
-    const suspenseIdx = content.indexOf('export function useSuspenseListLegacy')
-    expect(suspenseIdx).toBeGreaterThan(-1)
-    // @deprecated comment appears immediately before the function declaration
-    const before = content.slice(0, suspenseIdx)
-    expect(before.slice(before.lastIndexOf('/**'))).toContain('@deprecated')
-  })
-})
-
-// ── Feature #59: Per-resource staleTime and gcTime overrides ───────────────────
-
-describe('generateHooks — Feature #59: per-resource cache timing overrides', () => {
-  const multiResourceSpec: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/api/v1/tasks': {
-        get: {
-          operationId: 'listTasks',
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/api/v1/tasks/{id}': {
-        get: {
-          operationId: 'getTask',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/api/v1/platforms': {
-        get: {
-          operationId: 'listPlatforms',
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  it('overridden resource uses override staleTime and gcTime', () => {
-    const { content } = generateHooks(multiResourceSpec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      overrides: { tasks: { staleTime: 5000, gcTime: 60_000 } },
-    })
-    // useListTasks should use override staleTime 5000
-    const listTasksStart = content.indexOf('export function useListTasks')
-    const listTasksEnd = content.indexOf('\n}', listTasksStart) + 2
-    const listTasksContent = content.slice(listTasksStart, listTasksEnd)
-    expect(listTasksContent).toContain('staleTime: 5000,')
-    expect(listTasksContent).toContain('gcTime: 60000,')
-  })
-
-  it('non-overridden resource uses global defaults', () => {
-    const { content } = generateHooks(multiResourceSpec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      overrides: { tasks: { staleTime: 5000, gcTime: 60_000 } },
-    })
-    // useListPlatforms should use global staleTime 0
-    const listPlatformsStart = content.indexOf('export function useListPlatforms')
-    const listPlatformsEnd = content.indexOf('\n}', listPlatformsStart) + 2
-    const listPlatformsContent = content.slice(listPlatformsStart, listPlatformsEnd)
-    expect(listPlatformsContent).toContain('staleTime: 0,')
-    expect(listPlatformsContent).toContain('gcTime: 300000,')
-  })
-
-  it('overrides apply to both list and detail hooks of the same resource', () => {
-    const { content } = generateHooks(multiResourceSpec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      overrides: { tasks: { staleTime: 5000, gcTime: 60_000 } },
-    })
-    // useGetTask (detail) should also use override staleTime
-    const getTaskStart = content.indexOf('export function useGetTask')
-    const getTaskEnd = content.indexOf('\n}', getTaskStart) + 2
-    const getTaskContent = content.slice(getTaskStart, getTaskEnd)
-    expect(getTaskContent).toContain('staleTime: 5000,')
-    expect(getTaskContent).toContain('gcTime: 60000,')
-  })
-
-  it('no overrides — all hooks use global staleTime and gcTime', () => {
-    const { content } = generateHooks(multiResourceSpec, {
-      staleTime: 1000,
-      gcTime: 120_000,
-    })
-    // Count staleTime: 1000, occurrences — should appear for each query hook
-    const occurrences = content.split('staleTime: 1000,').length - 1
-    expect(occurrences).toBeGreaterThanOrEqual(3) // listTasks, getTask, listPlatforms
-  })
-})
-
-// ── Bug #75: Auto-invalidation key name with multiple detail ops ───────────────
-
-describe('generateHooks — Bug #75: auto-invalidation skips detail when multiple detail ops exist', () => {
-  const multiDetailSpec: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/items': {
-        get: {
-          operationId: 'listItems',
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/items/{id}': {
-        get: {
-          operationId: 'getItem',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-        put: {
-          operationId: 'updateItem',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: { type: 'object', properties: { name: { type: 'string' } } },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/items/{id}/summary': {
-        get: {
-          operationId: 'getItemSummary',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  it('key factory does NOT use "detail:" when there are multiple detail ops', () => {
-    const { content } = generateHooks(multiDetailSpec, {
-      staleTime: 0,
-      gcTime: 0,
-      autoInvalidate: true,
-    })
-    // With 2 detail ops (getItem + getItemSummary), the key factory uses operation-derived names
-    expect(content).not.toContain('detail:')
-  })
-
-  it('mutation hook does NOT reference itemKeys.detail( when there are multiple detail ops', () => {
-    const { content } = generateHooks(multiDetailSpec, {
-      staleTime: 0,
-      gcTime: 0,
-      autoInvalidate: true,
-    })
-    const updateStart = content.indexOf('export function useUpdateItem')
-    const updateEnd = content.indexOf('\n}', updateStart) + 2
-    const updateContent = content.slice(updateStart, updateEnd)
-    expect(updateContent).not.toContain('itemKeys.detail(')
-  })
-
-  it('mutation hook DOES contain itemKeys.all() for broad invalidation', () => {
-    const { content } = generateHooks(multiDetailSpec, {
-      staleTime: 0,
-      gcTime: 0,
-      autoInvalidate: true,
-    })
-    const updateStart = content.indexOf('export function useUpdateItem')
-    const updateEnd = content.indexOf('\n}', updateStart) + 2
-    const updateContent = content.slice(updateStart, updateEnd)
-    expect(updateContent).toContain('queryClient.invalidateQueries({ queryKey: itemKeys.all() })')
-  })
-})
-
-// ── Snapshot: full generated output ───────────────────────────────────────────
-
-describe('snapshot: full generated output', () => {
-  it('default options (staleTime: 0, gcTime: 300_000) — baseline', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000 })
-    expect(content).toMatchSnapshot()
-  })
-
-  it('autoInvalidate: true — auto-invalidation wiring', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000, autoInvalidate: true })
-    expect(content).toMatchSnapshot()
-  })
-
-  it('suspense: true — suspense hook variants', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000, suspense: true })
-    expect(content).toMatchSnapshot()
-  })
-
-  it('overrides: { tasks: { staleTime: 60_000, gcTime: 600_000 } } — per-resource timing', () => {
-    const { content } = generateHooks(spec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      overrides: { tasks: { staleTime: 60_000, gcTime: 600_000 } },
-    })
-    expect(content).toMatchSnapshot()
-  })
-
-  it('autoInvalidate: true, suspense: true, overrides: { tasks: { staleTime: 60_000 } } — all features combined', () => {
-    const { content } = generateHooks(spec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      autoInvalidate: true,
-      suspense: true,
-      overrides: { tasks: { staleTime: 60_000 } },
-    })
-    expect(content).toMatchSnapshot()
-  })
-})
-
-// ── Feature interactions ────────────────────────────────────────────────────────
-
-describe('feature interactions', () => {
-  it('Test A: suspense + overrides apply correct staleTime to suspense and regular hooks', () => {
-    const { content } = generateHooks(spec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      suspense: true,
-      overrides: { tasks: { staleTime: 60_000, gcTime: 600_000 } },
-    })
-
-    // Suspense hook for getTask should exist and contain the overridden staleTime
-    const suspenseHookStart = content.indexOf('export function useSuspenseGetTask')
-    const suspenseHookEnd = content.indexOf('\n}', suspenseHookStart) + 2
-    const suspenseHookContent = content.slice(suspenseHookStart, suspenseHookEnd)
-    expect(suspenseHookContent).toContain('staleTime: 60000,')
-
-    // Regular useGetTask hook should also get the override
-    const regularHookStart = content.indexOf('export function useGetTask')
-    const regularHookEnd = content.indexOf('\n}', regularHookStart) + 2
-    const regularHookContent = content.slice(regularHookStart, regularHookEnd)
-    expect(regularHookContent).toContain('staleTime: 60000,')
-  })
-
-  it('Test B: autoInvalidate + overrides coexist without conflict', () => {
-    const { content } = generateHooks(spec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      autoInvalidate: true,
-      overrides: { tasks: { staleTime: 30_000 } },
-    })
-
-    // Mutation hook still has invalidateQueries (auto-invalidation works)
-    const createHookStart = content.indexOf('export function useCreateTask')
-    const createHookEnd = content.indexOf('\n}', createHookStart) + 2
-    const createHookContent = content.slice(createHookStart, createHookEnd)
-    expect(createHookContent).toContain('invalidateQueries')
-
-    // Query hook still has the overridden staleTime (overrides work)
-    const listHookStart = content.indexOf('export function useListTasks')
-    const listHookEnd = content.indexOf('\n}', listHookStart) + 2
-    const listHookContent = content.slice(listHookStart, listHookEnd)
-    expect(listHookContent).toContain('staleTime: 30000,')
-  })
-
-  it('Test C: suspense + autoInvalidate produces both variants and invalidation', () => {
-    const { content } = generateHooks(spec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      suspense: true,
-      autoInvalidate: true,
-    })
-
-    // Both regular and suspense hooks are generated
-    expect(content).toContain('export function useListTasks')
-    expect(content).toContain('export function useSuspenseListTasks')
-    expect(content).toContain('export function useGetTask')
-    expect(content).toContain('export function useSuspenseGetTask')
-
-    // Mutation hooks still have invalidateQueries
-    const createHookStart = content.indexOf('export function useCreateTask')
-    const createHookEnd = content.indexOf('\n}', createHookStart) + 2
-    const createHookContent = content.slice(createHookStart, createHookEnd)
-    expect(createHookContent).toContain('invalidateQueries')
-  })
-})
-
-describe('auto-invalidate mutations (#58)', () => {
-  it('autoInvalidate: false — no useQueryClient or invalidateQueries in output', () => {
-    const { content } = generateHooks(spec, {
-      staleTime: 0,
-      gcTime: 300_000,
-      autoInvalidate: false,
-    })
-    expect(content).not.toContain('useQueryClient')
-    expect(content).not.toContain('invalidateQueries')
-  })
-
-  it('autoInvalidate: true — imports useQueryClient from @tanstack/react-query', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000, autoInvalidate: true })
-    expect(content).toContain('useQueryClient')
-    expect(content).toContain("from '@tanstack/react-query'")
-  })
-
-  it('autoInvalidate: true — useCreateTask invalidates taskKeys.all()', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000, autoInvalidate: true })
-    const createStart = content.indexOf('export function useCreateTask')
-    const createEnd = content.indexOf('\n}', createStart) + 2
-    const createContent = content.slice(createStart, createEnd)
-    expect(createContent).toContain('queryClient.invalidateQueries({ queryKey: taskKeys.all() })')
-    // Uses spread pattern — no named (data, variables, context) args
-    expect(createContent).toContain('onSuccess: (...args) =>')
-    expect(createContent).toContain('options?.onSuccess?.(...args)')
-    // No detail invalidation for POST — no destructure needed
-    expect(createContent).not.toContain('const [, variables] = args')
-  })
-
-  it('autoInvalidate: true — useUpdateTask invalidates taskKeys.all() and taskKeys.detail()', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000, autoInvalidate: true })
-    const updateStart = content.indexOf('export function useUpdateTask')
-    const updateEnd = content.indexOf('\n}', updateStart) + 2
-    const updateContent = content.slice(updateStart, updateEnd)
-    expect(updateContent).toContain('queryClient.invalidateQueries({ queryKey: taskKeys.all() })')
-    expect(updateContent).toContain('taskKeys.detail(')
-    // Uses spread pattern
-    expect(updateContent).toContain('onSuccess: (...args) =>')
-    expect(updateContent).toContain('options?.onSuccess?.(...args)')
-    // PUT with path param — destructures variables from args for detail invalidation
-    expect(updateContent).toContain('const [, variables] = args')
-  })
-
-  it('autoInvalidate: true — useDeleteTask invalidates taskKeys.all() but not detail', () => {
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 300_000, autoInvalidate: true })
-    const deleteStart = content.indexOf('export function useDeleteTask')
-    const deleteEnd = content.indexOf('\n}', deleteStart) + 2
-    const deleteContent = content.slice(deleteStart, deleteEnd)
-    expect(deleteContent).toContain('queryClient.invalidateQueries({ queryKey: taskKeys.all() })')
-    // DELETE should NOT invalidate detail (only PUT/PATCH do)
-    expect(deleteContent).not.toContain('taskKeys.detail(')
-    // Uses spread pattern
-    expect(deleteContent).toContain('onSuccess: (...args) =>')
-    expect(deleteContent).toContain('options?.onSuccess?.(...args)')
-    // No detail invalidation for DELETE — no destructure needed
-    expect(deleteContent).not.toContain('const [, variables] = args')
-  })
-})
-
-// ── All 12 mutation hook variable shapes ────────────────────────────────────────
-
-describe('mutation hook variables type — all 12 shapes', () => {
-  // Single spec covering all 12 (pathParams × hasBody × hasQueryParams) branches
-  const allShapesSpec: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      // Case 1: 0 path params, no body, no query → void
-      '/a': {
-        delete: {
-          operationId: 'deleteA',
-          responses: { '204': { description: 'no content' } },
-        },
-      },
-      // Case 2: 0 path params, no body, has query → Parameters<typeof fn>[0]
-      '/b': {
-        post: {
-          operationId: 'postB',
-          parameters: [{ name: 'filter', in: 'query', schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      // Case 3: 0 path params, has body, no query → Parameters<typeof fn>[0]
-      '/c': {
-        post: {
-          operationId: 'postC',
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '201': { description: 'created' } },
-        },
-      },
-      // Case 4: 0 path params, has body, has query → { body: ...[0]; params: ...[1] }
-      '/d': {
-        post: {
-          operationId: 'postD',
-          parameters: [{ name: 'dryRun', in: 'query', schema: { type: 'string' } }],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      // Case 5: 1 path param, no body, no query → string
-      '/e/{id}': {
-        delete: {
-          operationId: 'deleteE',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '204': { description: 'no content' } },
-        },
-      },
-      // Case 6: 1 path param, no body, has query → { id: string; params: ...[1] }
-      '/f/{id}': {
-        delete: {
-          operationId: 'deleteF',
-          parameters: [
-            { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'cascade', in: 'query', schema: { type: 'string' } },
-          ],
-          responses: { '204': { description: 'no content' } },
-        },
-      },
-      // Case 7: 1 path param, has body, no query → { id: string; body: ...[1] }
-      '/g/{id}': {
-        put: {
-          operationId: 'putG',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      // Case 8: 1 path param, has body, has query → { id: string; body: ...[1]; params: ...[2] }
-      '/h/{id}': {
-        put: {
-          operationId: 'putH',
-          parameters: [
-            { name: 'id', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'dryRun', in: 'query', schema: { type: 'string' } },
-          ],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      // Case 9: 2+ path params, no body, no query → { projectId: string; taskId: string }
-      '/i/{projectId}/{taskId}': {
-        delete: {
-          operationId: 'deleteI',
-          parameters: [
-            { name: 'projectId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'taskId', in: 'path', required: true, schema: { type: 'string' } },
-          ],
-          responses: { '204': { description: 'no content' } },
-        },
-      },
-      // Case 10: 2+ path params, no body, has query → { projectId: string; taskId: string; params: ...[2] }
-      '/j/{projectId}/{taskId}': {
-        delete: {
-          operationId: 'deleteJ',
-          parameters: [
-            { name: 'projectId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'taskId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'recursive', in: 'query', schema: { type: 'string' } },
-          ],
-          responses: { '204': { description: 'no content' } },
-        },
-      },
-      // Case 11: 2+ path params, has body, no query → { projectId: string; taskId: string; body: ...[2] }
-      '/k/{projectId}/{taskId}': {
-        put: {
-          operationId: 'putK',
-          parameters: [
-            { name: 'projectId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'taskId', in: 'path', required: true, schema: { type: 'string' } },
-          ],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      // Case 12: 2+ path params, has body, has query → { projectId: string; taskId: string; body: ...[2]; params: ...[3] }
-      '/l/{projectId}/{taskId}': {
-        put: {
-          operationId: 'putL',
-          parameters: [
-            { name: 'projectId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'taskId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'dryRun', in: 'query', schema: { type: 'string' } },
-          ],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  const { content: shapesContent } = generateHooks(allShapesSpec, { staleTime: 0, gcTime: 0 })
-
-  it('case 1 (0 params, no body, no query): variablesType is void, mutationFn is () => fn()', () => {
-    // UseMutationOptions<..., ApiError, void> — void is the variables type
-    expect(shapesContent).toContain(
-      'UseMutationOptions<Awaited<ReturnType<typeof deleteA>>, ApiError, void>'
-    )
-    expect(shapesContent).toContain('mutationFn: () => deleteA()')
-  })
-
-  it('case 2 (0 params, no body, has query): variablesType is Parameters<typeof fn>[0], mutationFn is (vars) => fn(vars)', () => {
-    expect(shapesContent).toContain(
-      'UseMutationOptions<Awaited<ReturnType<typeof postB>>, ApiError, Parameters<typeof postB>[0]>'
-    )
-    expect(shapesContent).toContain('mutationFn: (vars) => postB(vars)')
-  })
-
-  it('case 3 (0 params, has body, no query): variablesType is Parameters<typeof fn>[0], mutationFn is (vars) => fn(vars)', () => {
-    expect(shapesContent).toContain(
-      'UseMutationOptions<Awaited<ReturnType<typeof postC>>, ApiError, Parameters<typeof postC>[0]>'
-    )
-    expect(shapesContent).toContain('mutationFn: (vars) => postC(vars)')
-  })
-
-  it('case 4 (0 params, has body, has query): variablesType is { body: ...[0]; params: ...[1] }, mutationFn destructures both', () => {
-    expect(shapesContent).toContain(
-      'body: Parameters<typeof postD>[0]; params: Parameters<typeof postD>[1]'
-    )
-    expect(shapesContent).toContain('mutationFn: ({ body, params }) => postD(body, params)')
-  })
-
-  it('case 5 (1 path param, no body, no query): variablesType is string, mutationFn is (id) => fn(id)', () => {
-    // string is the entire variables type — only case that uses literal 'string'
-    expect(shapesContent).toContain(
-      'UseMutationOptions<Awaited<ReturnType<typeof deleteE>>, ApiError, string>'
-    )
-    expect(shapesContent).toContain('mutationFn: (id) => deleteE(id)')
-  })
-
-  it('case 6 (1 path param, no body, has query): variablesType is { id: string; params: ...[1] }, mutationFn destructures { id, params }', () => {
-    expect(shapesContent).toContain('id: string; params: Parameters<typeof deleteF>[1]')
-    expect(shapesContent).toContain('mutationFn: ({ id, params }) => deleteF(id, params)')
-  })
-
-  it('case 7 (1 path param, has body, no query): variablesType is { id: string; body: ...[1] }, mutationFn destructures { id, body }', () => {
-    expect(shapesContent).toContain('id: string; body: Parameters<typeof putG>[1]')
-    expect(shapesContent).toContain('mutationFn: ({ id, body }) => putG(id, body)')
-  })
-
-  it('case 8 (1 path param, has body, has query): variablesType is { id: string; body: ...[1]; params: ...[2] }, mutationFn destructures all', () => {
-    expect(shapesContent).toContain(
-      'id: string; body: Parameters<typeof putH>[1]; params: Parameters<typeof putH>[2]'
-    )
-    expect(shapesContent).toContain('mutationFn: ({ id, body, params }) => putH(id, body, params)')
-  })
-
-  it('case 9 (2+ params, no body, no query): variablesType is { projectId: string; taskId: string }, mutationFn destructures both path params', () => {
-    expect(shapesContent).toContain('projectId: string; taskId: string }')
-    expect(shapesContent).toContain(
-      'mutationFn: ({ projectId, taskId }) => deleteI(projectId, taskId)'
-    )
-  })
-
-  it('case 10 (2+ params, no body, has query): variablesType includes both path params and params, mutationFn passes all', () => {
-    expect(shapesContent).toContain(
-      'projectId: string; taskId: string; params: Parameters<typeof deleteJ>[2]'
-    )
-    expect(shapesContent).toContain(
-      'mutationFn: ({ projectId, taskId, params }) => deleteJ(projectId, taskId, params)'
-    )
-  })
-
-  it('case 11 (2+ params, has body, no query): variablesType includes both path params and body at index [2]', () => {
-    expect(shapesContent).toContain(
-      'projectId: string; taskId: string; body: Parameters<typeof putK>[2]'
-    )
-    expect(shapesContent).toContain(
-      'mutationFn: ({ projectId, taskId, body }) => putK(projectId, taskId, body)'
-    )
-  })
-
-  it('case 12 (2+ params, has body, has query): variablesType includes both path params, body at [2], params at [3]', () => {
-    expect(shapesContent).toContain(
-      'projectId: string; taskId: string; body: Parameters<typeof putL>[2]; params: Parameters<typeof putL>[3]'
-    )
-    expect(shapesContent).toContain(
-      'mutationFn: ({ projectId, taskId, body, params }) => putL(projectId, taskId, body, params)'
-    )
-  })
-})
-
-// ── Auto-invalidate: method-based detail invalidation ───────────────────────────
-
-describe('auto-invalidate: method-based detail invalidation', () => {
-  const thingsSpec: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      // GET list — establishes the resource key factory with all(), list(), detail()
-      '/things': {
-        get: {
-          operationId: 'listThings',
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/things/{id}': {
-        // GET detail — needed so detailKeyName = 'detail' (exactly 1 detail op)
-        get: {
-          operationId: 'getThing',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-        // PUT — should invalidate all() AND detail() (method === 'put', pathParams.length >= 1)
-        put: {
-          operationId: 'updateThing',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-        // PATCH — should invalidate all() AND detail() (method === 'patch', pathParams.length >= 1)
-        patch: {
-          operationId: 'patchThing',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          requestBody: {
-            required: true,
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object' as const,
-                  properties: { name: { type: 'string' as const } },
-                },
-              },
-            },
-          },
-          responses: { '200': { description: 'ok' } },
-        },
-        // DELETE — should invalidate all() ONLY (method !== 'put'/'patch')
-        delete: {
-          operationId: 'deleteThing',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '204': { description: 'no content' } },
-        },
-      },
-    },
-  }
-
-  const { content: thingsContent } = generateHooks(thingsSpec, {
-    staleTime: 0,
-    gcTime: 0,
-    autoInvalidate: true,
-  })
-
-  it('thingKeys key factory has a detail entry (exactly one detail GET op)', () => {
-    expect(thingsContent).toContain('export const thingKeys')
-    expect(thingsContent).toContain('detail:')
-  })
-
-  it('useUpdateThing (PUT) invalidates thingKeys.all() AND thingKeys.detail(', () => {
-    const updateStart = thingsContent.indexOf('export function useUpdateThing')
-    const updateEnd = thingsContent.indexOf('\n}', updateStart) + 2
-    const updateHookContent = thingsContent.slice(updateStart, updateEnd)
-    expect(updateHookContent).toContain('thingKeys.all()')
-    expect(updateHookContent).toContain('thingKeys.detail(')
-  })
-
-  it('usePatchThing (PATCH) invalidates thingKeys.all() AND thingKeys.detail(', () => {
-    const patchStart = thingsContent.indexOf('export function usePatchThing')
-    const patchEnd = thingsContent.indexOf('\n}', patchStart) + 2
-    const patchHookContent = thingsContent.slice(patchStart, patchEnd)
-    expect(patchHookContent).toContain('thingKeys.all()')
-    expect(patchHookContent).toContain('thingKeys.detail(')
-  })
-
-  it('useDeleteThing (DELETE) invalidates thingKeys.all() but NOT thingKeys.detail(', () => {
-    const deleteStart = thingsContent.indexOf('export function useDeleteThing')
-    const deleteEnd = thingsContent.indexOf('\n}', deleteStart) + 2
-    const deleteHookContent = thingsContent.slice(deleteStart, deleteEnd)
-    expect(deleteHookContent).toContain('thingKeys.all()')
-    expect(deleteHookContent).not.toContain('thingKeys.detail(')
-  })
-
-  it('PUT hook uses const [, variables] = args to extract id for detail invalidation', () => {
-    const updateStart = thingsContent.indexOf('export function useUpdateThing')
-    const updateEnd = thingsContent.indexOf('\n}', updateStart) + 2
-    const updateHookContent = thingsContent.slice(updateStart, updateEnd)
-    expect(updateHookContent).toContain('const [, variables] = args')
-  })
-
-  it('PATCH hook uses const [, variables] = args to extract id for detail invalidation', () => {
-    const patchStart = thingsContent.indexOf('export function usePatchThing')
-    const patchEnd = thingsContent.indexOf('\n}', patchStart) + 2
-    const patchHookContent = thingsContent.slice(patchStart, patchEnd)
-    expect(patchHookContent).toContain('const [, variables] = args')
-  })
-
-  it('DELETE hook does NOT use const [, variables] = args (no detail invalidation)', () => {
-    const deleteStart = thingsContent.indexOf('export function useDeleteThing')
-    const deleteEnd = thingsContent.indexOf('\n}', deleteStart) + 2
-    const deleteHookContent = thingsContent.slice(deleteStart, deleteEnd)
-    expect(deleteHookContent).not.toContain('const [, variables] = args')
-  })
-})
-
-// ── Query hook key builder — 2+ path params with query params ───────────────────
-
-describe('query hook key builder — 2+ path params with query params', () => {
-  const multiParamQuerySpec: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/projects/{projectId}/tasks/{taskId}': {
-        get: {
-          operationId: 'getProjectTask',
-          parameters: [
-            { name: 'projectId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'taskId', in: 'path', required: true, schema: { type: 'string' } },
-            { name: 'format', in: 'query', schema: { type: 'string' } },
-          ],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  const { content: multiParamContent } = generateHooks(multiParamQuerySpec, {
-    staleTime: 0,
-    gcTime: 0,
-  })
-
-  it('key factory detail entry accepts both path params as typed args', () => {
-    expect(multiParamContent).toContain('(projectId: string, taskId: string,')
-  })
-
-  it('hook signature includes both path params as string | undefined | null', () => {
-    expect(multiParamContent).toContain('projectId: string | undefined | null')
-    expect(multiParamContent).toContain('taskId: string | undefined | null')
-  })
-
-  it('enabled guard ANDs both path params', () => {
-    expect(multiParamContent).toContain(
-      'enabled: projectId != null && taskId != null && (options?.enabled ?? true)'
-    )
-  })
-
-  it('queryKey call includes both path params with non-null assertions and query params', () => {
-    expect(multiParamContent).toContain('projectId!, taskId!, params')
-  })
-})
-
-// ── Edge cases: deprecated, no operationId, empty spec, multiple list ops ──────
-
-describe('generateHooks — edge cases', () => {
-  it('marks deprecated mutation hook with @deprecated JSDoc', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/pets': {
-          post: {
-            operationId: 'createPet',
-            deprecated: true,
-            requestBody: {
-              required: true,
-              content: { 'application/json': { schema: { type: 'object' } } },
-            },
-            responses: { '201': { description: 'Created' } },
-          },
-        },
-      },
-    }
-    const { content: result } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(result).toContain('/** @deprecated */')
-  })
-
-  it('generates hook name from method+path when operationId is absent', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/pets/{id}': {
-          get: {
-            // no operationId
-            parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content: result } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // Should have a hook function — exact name depends on deriveOperationName
-    expect(result).toContain('export function use')
-  })
-
-  it('generates valid output for spec with no operations', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Empty', version: '1.0.0' },
-      paths: {},
-    }
-    const { content: result } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(result).toContain("import { type ApiError } from './client.js'")
-    expect(result).not.toContain('export function use')
-  })
-
-  it('generates operation-derived key names when multiple list ops exist for same resource', () => {
-    // Two GET operations with no path params sharing the same primary resource "items"
-    // triggers the listOps.length > 1 branch in key factory generation
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/items': {
-          get: {
-            operationId: 'listItems',
-            responses: {
-              '200': {
-                description: 'ok',
-                content: {
-                  'application/json': { schema: { type: 'array', items: { type: 'object' } } },
-                },
-              },
-            },
-          },
-        },
-        '/items/search': {
-          get: {
-            operationId: 'searchItems',
-            parameters: [{ name: 'q', in: 'query', schema: { type: 'string' } }],
-            responses: {
-              '200': {
-                description: 'ok',
-                content: {
-                  'application/json': { schema: { type: 'array', items: { type: 'object' } } },
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-    const { content: result } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // With multiple list ops, key factory uses operationId-derived keys, NOT generic 'list:'
-    expect(result).toContain('export const itemKeys')
-    expect(result).not.toContain('list:')
-    // Both operations should appear as named entries
-    expect(result).toContain('listItems:')
-    expect(result).toContain('searchItems:')
-  })
-})
-
-// ── Bug #105: cache key collision ─────────────────────────────────────────────
-
-describe('Bug #105: cache key collision when multiple GET ops share same path param', () => {
-  const specWithMultipleDetailOps: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/items/{id}': {
-        get: {
-          operationId: 'getItemById',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-      '/items/{id}/usage': {
-        get: {
-          operationId: 'getItemUsage',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '200': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  const { content: multiDetailResult } = generateHooks(specWithMultipleDetailOps, {
-    staleTime: 0,
-    gcTime: 0,
-  })
-
-  it('both operations have distinct named entries in the key factory', () => {
-    expect(multiDetailResult).toContain('getItemById:')
-    expect(multiDetailResult).toContain('getItemUsage:')
-  })
-
-  it('getItemById key includes operation name as distinguishing segment', () => {
-    // Must be ['items', 'getItemById', id] — not ['items', id] which would collide
-    expect(multiDetailResult).toContain("'items', 'getItemById', id")
-  })
-
-  it('getItemUsage key includes operation name as distinguishing segment', () => {
-    expect(multiDetailResult).toContain("'items', 'getItemUsage', id")
-  })
-
-  it('the two key arrays are structurally distinct (no collision)', () => {
-    const byIdLine = multiDetailResult.match(/getItemById:.*?as const/)
-    const usageLine = multiDetailResult.match(/getItemUsage:.*?as const/)
-    expect(byIdLine).toBeTruthy()
-    expect(usageLine).toBeTruthy()
-    expect(byIdLine![0]).not.toBe(usageLine![0])
-  })
-
-  it('single detail op still uses canonical ["resource", id] key (no breaking change)', () => {
-    const specSingleDetail: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/items/{id}': {
-          get: {
-            operationId: 'getItemById',
-            parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content: result } = generateHooks(specSingleDetail, { staleTime: 0, gcTime: 0 })
-    // Single detail op → 'detail' key → ['items', id] unchanged
-    expect(result).toContain('detail:')
-    expect(result).toContain("'items', id")
-    expect(result).not.toContain("'items', 'detail', id")
-  })
-})
-
-// ── Bug: path segments with hyphens produce invalid identifiers ───────────────
-
-describe('generateHooks — path segment sanitization in deriveOperationName', () => {
-  it('/api-keys (no operationId) → createApiKeys (not createApi-keys)', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/api-keys': {
-          post: {
-            // no operationId — forces deriveOperationName
-            responses: { '201': { description: 'created' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('createApiKeys')
-    expect(content).not.toContain('createApi-keys')
-  })
-
-  it('GET /api-keys → useGetApiKeys (not useGetApi-keys)', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/api-keys': {
-          get: {
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('export function useGetApiKeys')
-    expect(content).not.toContain('useGetApi-keys')
-  })
-
-  it('path param {api-key-id} → ByApiKeyId (not ByApi-key-id)', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/api-keys/{api-key-id}': {
-          get: {
-            parameters: [
-              { name: 'api-key-id', in: 'path', required: true, schema: { type: 'string' } },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('GetApiKeysByApiKeyId')
-    expect(content).not.toContain('Api-key')
-  })
-})
-
-// ── Bug: AWS action-style resource names with special chars ────────────────────
-
-describe('generateHooks — toKeyFactoryName sanitizes special chars', () => {
-  it('resource "#Action=ActivateType" produces valid key factory name', () => {
-    // AWS-style paths use query params embedded in the path segment
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/#Action=ActivateType': {
-          post: {
-            operationId: 'ActivateType',
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // The key factory name must be a valid JS identifier — no #, =, & chars
-    expect(content).not.toContain('#Action=ActivateTypeKeys')
-    expect(content).not.toMatch(/export const [^a-zA-Z_$]/)
-  })
-
-  it('path param with hyphens like {attachment-publicUUID} sanitized in key factory', () => {
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/attachments/{attachment-publicUUID}': {
-          get: {
-            operationId: 'getAttachment',
-            parameters: [
-              {
-                name: 'attachment-publicUUID',
-                in: 'path',
-                required: true,
-                schema: { type: 'string' },
-              },
-            ],
-            responses: { '200': { description: 'ok' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    // The path param name must be sanitized to a valid JS identifier
-    expect(content).not.toContain('attachment-publicUUID:')
-    expect(content).not.toContain('attachment-publicUUID!')
-    // The sanitized form attachmentPublicUUID should appear instead
-    expect(content).toContain('attachmentPublicUUID')
-  })
-})
-
-// ── Bug #106: ...options spread overwrites auto-invalidation onSuccess ────────
-
-describe('Bug #106: ...options spread must not overwrite auto-invalidation onSuccess', () => {
-  const specWithAutoInvalidate: OpenAPIV3_1.Document = {
-    openapi: '3.1.0',
-    info: { title: 'Test', version: '1.0.0' },
-    paths: {
-      '/items': {
-        get: {
-          operationId: 'listItems',
-          responses: { '200': { description: 'ok' } },
-        },
-        post: {
-          operationId: 'createItem',
-          requestBody: {
-            required: true,
-            content: { 'application/json': { schema: { $ref: '#/components/schemas/Item' } } },
-          },
-          responses: { '201': { description: 'ok' } },
-        },
-      },
-      '/items/{id}': {
-        delete: {
-          operationId: 'deleteItem',
-          parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-          responses: { '204': { description: 'ok' } },
-        },
-      },
-    },
-  }
-
-  const { content: autoInvalidateResult } = generateHooks(specWithAutoInvalidate, {
-    staleTime: 0,
-    gcTime: 0,
-    autoInvalidate: true,
-  })
-
-  it('...options spread appears BEFORE onSuccess in mutation hook with auto-invalidation', () => {
-    const hookStart = autoInvalidateResult.indexOf('export function useCreateItem')
-    const hookEnd = autoInvalidateResult.indexOf('\n}', hookStart) + 2
-    const hookContent = autoInvalidateResult.slice(hookStart, hookEnd)
-
-    const spreadIdx = hookContent.indexOf('...options,')
-    const onSuccessIdx = hookContent.indexOf('onSuccess:')
-
-    expect(spreadIdx).toBeGreaterThan(-1)
-    expect(onSuccessIdx).toBeGreaterThan(-1)
-    // spread must come BEFORE onSuccess so the generated onSuccess always wins
-    expect(spreadIdx).toBeLessThan(onSuccessIdx)
-  })
-
-  it('generated onSuccess still composes options.onSuccess so callers can react to success', () => {
-    expect(autoInvalidateResult).toContain('options?.onSuccess?.(...args)')
-  })
-
-  it('mutation hook without auto-invalidation is unaffected (no onSuccess generated)', () => {
-    const { content: plain } = generateHooks(specWithAutoInvalidate, {
-      staleTime: 0,
-      gcTime: 0,
-      autoInvalidate: false,
-    })
-    const hookStart = plain.indexOf('export function useCreateItem')
-    const hookEnd = plain.indexOf('\n}', hookStart) + 2
-    const hookContent = plain.slice(hookStart, hookEnd)
-    expect(hookContent).not.toContain('onSuccess:')
-  })
-})
-
-describe('coverage: spec without paths property — generates empty output', () => {
-  it('spec with paths=undefined produces a valid but empty hooks file', () => {
-    // Covers the `if (paths !== undefined)` false branch in generateHooks (line 542)
-    const spec = {
-      openapi: '3.1.0',
-      info: { title: 'Empty', version: '1.0.0' },
-      // no paths property
-    } as OpenAPIV3_1.Document
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(content).toBeDefined()
-    // No hooks generated — just the header boilerplate
-    expect(content).not.toContain('export function use')
-  })
-})
-
-describe('coverage: requestBody with no content — hasBody but no bodyTypeName', () => {
-  it('POST with requestBody missing content property produces mutation without typed body', () => {
-    // Covers `if (content === undefined) return { hasBody: true, bodyTypeName: undefined }` (line 112)
-    const spec: OpenAPIV3_1.Document = {
-      openapi: '3.1.0',
-      info: { title: 'Test', version: '1.0.0' },
-      paths: {
-        '/items': {
-          post: {
-            operationId: 'createItem',
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            requestBody: { required: true } as any, // no content property
-            responses: { '201': { description: 'created' } },
-          },
-        },
-      },
-    }
-    const { content } = generateHooks(spec, { staleTime: 0, gcTime: 0 })
-    expect(content).toContain('export function useCreateItem')
-  })
-})