@archora/forge-cli 2.0.0 → 2.1.0

package/dist/{chunk-RL23SDLM.js → chunk-FSB2T27T.js}

@@ -140,7 +140,9 @@ async function loadForgeConfig(filePath) {
 }
 function parseConfig(value) {
   if (!isForgeConfig(value)) {
-    throw new Error("Invalid Archora Forge config: `input` must be a string or `inputs` must contain at least one schema entry.");
+    throw new Error(
+      "Invalid Archora Forge config: `input` must be a string or `inputs` must contain at least one schema entry."
+    );
   }
   return value;
 }
@@ -158,7 +160,10 @@ function loadConfigFromSource(source) {
   if (!match?.[1]) {
     return null;
   }
-  const createConfig = new Function("defineForgeConfig", `return defineForgeConfig(${match[1]})`);
+  const createConfig = new Function(
+    "defineForgeConfig",
+    `return defineForgeConfig(${match[1]})`
+  );
   return parseConfig(createConfig(defineForgeConfig));
 }
 
@@ -872,7 +877,7 @@ var ForgeError = class extends Error {
     this.details = details;
   }
 };
-var forgeCoreVersion = "2.0.0";
+var forgeCoreVersion = "2.1.0";
 var forgeGeneratedMarker = "// @archora-forge-generated";
 var forgeGeneratedMetadataMarker = "// @archora-forge-meta";
 async function writeGeneratedFiles(files, options) {
@@ -1270,10 +1275,14 @@ function createOperationTypeNames(operation) {
 }
 function createTypeScriptTypes(normalized, resource) {
   const declarations = [];
-  if (!normalized.schemas.some((schema) => toSafeTypeName(schema.name) === toSafeTypeName(resource.entity))) {
-    declarations.push(`export interface ${toSafeTypeName(resource.entity)} {
+  if (!normalized.schemas.some(
+    (schema) => toSafeTypeName(schema.name) === toSafeTypeName(resource.entity)
+  )) {
+    declarations.push(
+      `export interface ${toSafeTypeName(resource.entity)} {
   [key: string]: unknown
-}`);
+}`
+    );
   }
   declarations.push(createOperationAliases(normalized, resource));
   const body = declarations.filter(Boolean).join("\n\n");
@@ -1290,13 +1299,19 @@ function createSharedSchemaTypes(normalized) {
   const declarations = [];
   const enumAliases = /* @__PURE__ */ new Map();
   for (const schema of normalized.schemas) {
-    declarations.push(createSchemaDeclaration(normalized, toSafeTypeName(schema.name), schema.schema, enumAliases));
+    declarations.push(
+      createSchemaDeclaration(normalized, toSafeTypeName(schema.name), schema.schema, enumAliases)
+    );
   }
-  declarations.unshift(...[...enumAliases.entries()].map(([name, value]) => `export type ${name} = ${value}`));
+  declarations.unshift(
+    ...[...enumAliases.entries()].map(([name, value]) => `export type ${name} = ${value}`)
+  );
   return declarations.length > 0 ? `${declarations.filter(Boolean).join("\n\n")}
 ` : "export {}\n";
 }
-function schemaToTypeScript(normalized, schema, options = { mode: "response" }) {
+function schemaToTypeScript(normalized, schema, options = {
+  mode: "response"
+}) {
   if (!schema) return "unknown";
   if (schema.$ref) return toSafeTypeName(schema.$ref.split("/").at(-1) ?? "unknown");
   const unwrappedAllOf = unwrapAnnotationOnlyAllOfSchema(schema);
@@ -1314,27 +1329,42 @@ function schemaToTypeScript(normalized, schema, options = { mode: "response" })
   }
   if (hasConst(schema)) return enumValueToTypeScript(schema.const);
   if (schema.enum) return schema.enum.map(enumValueToTypeScript).join(" | ");
-  if (schema.type === "string" && schema.format === "binary") return options.mode === "request" || options.indent !== void 0 ? "Blob | File" : "Blob";
+  if (schema.type === "string" && schema.format === "binary")
+    return options.mode === "request" || options.indent !== void 0 ? "Blob | File" : "Blob";
   if (schema.type === "string") return "string";
   if (schema.type === "number" || schema.type === "integer") return "number";
   if (schema.type === "boolean") return "boolean";
-  if (schema.type === "array") return `${toArrayElementType(schemaToTypeScript(normalized, schema.items, options))}[]`;
-  if (isPureDictionarySchema(schema)) return createDictionaryType(normalized, schema.additionalProperties, options);
+  if (schema.type === "array")
+    return `${toArrayElementType(schemaToTypeScript(normalized, schema.items, options))}[]`;
+  if (isPureDictionarySchema(schema))
+    return createDictionaryType(normalized, schema.additionalProperties, options);
   if (schema.type === "object" && !schema.properties) return "Record<string, unknown>";
   if (schema.type === "object" || schema.properties) {
     const indent = options.indent ?? 0;
     const childIndent = " ".repeat(indent + 2);
     const closeIndent = " ".repeat(indent);
     const required = new Set(schema.required ?? []);
-    const lines = Object.entries(schema.properties ?? {}).filter(([, property]) => options.mode === "request" ? !property.readOnly : !property.writeOnly).map(([name, property]) => {
+    const lines = Object.entries(schema.properties ?? {}).filter(
+      ([, property]) => options.mode === "request" ? !property.readOnly : !property.writeOnly
+    ).map(([name, property]) => {
       const optional = required.has(name) ? "" : "?";
       const nullable = property.nullable ? " | null" : "";
-      return `${childIndent}${quoteObjectKeyIfNeeded(name)}${optional}: ${schemaToTypeScript(normalized, property, {
-        ...options,
-        indent: indent + 2
-      })}${nullable}`;
+      return `${childIndent}${quoteObjectKeyIfNeeded(name)}${optional}: ${schemaToTypeScript(
+        normalized,
+        property,
+        {
+          ...options,
+          indent: indent + 2
+        }
+      )}${nullable}`;
     });
-    const indexSignature = createAdditionalPropertiesIndex(normalized, schema, options, childIndent, required);
+    const indexSignature = createAdditionalPropertiesIndex(
+      normalized,
+      schema,
+      options,
+      childIndent,
+      required
+    );
     if (indexSignature) lines.push(indexSignature);
     return `{
 ${lines.join("\n")}
@@ -1359,18 +1389,50 @@ function getDiscriminatorInfo(schema) {
 function renderUnionBranch(normalized, branch, options, discriminator) {
   const type = schemaToTypeScript(normalized, branch, options);
   if (!discriminator || type === "unknown" || !isObjectSchemaBranch(normalized, branch)) return type;
-  const literal = discriminatorLiteral(discriminator, branch);
+  const literal = discriminatorLiteral(normalized, discriminator, branch);
   if (literal === null) return type;
   return `(${type} & { ${quoteObjectKeyIfNeeded(discriminator.propertyName)}: ${JSON.stringify(literal)} })`;
 }
-function discriminatorLiteral(discriminator, branch) {
+function discriminatorLiteral(normalized, discriminator, branch) {
   if (!branch.$ref) return null;
   const refName = branch.$ref.split("/").at(-1) ?? "";
   for (const [key, target] of Object.entries(discriminator.mapping)) {
     if (target === branch.$ref || target.split("/").at(-1) === refName) return key;
   }
+  const candidates = discriminatorPropertyLiterals(normalized, branch, discriminator.propertyName);
+  if (candidates.length > 0) {
+    const exact = candidates.find((value) => value === refName);
+    if (exact !== void 0) return exact;
+    const caseInsensitive = candidates.find(
+      (value) => value.toLowerCase() === refName.toLowerCase()
+    );
+    if (caseInsensitive !== void 0) return caseInsensitive;
+    if (candidates.length === 1) return candidates[0] ?? null;
+  }
   return refName.length > 0 ? refName : null;
 }
+function discriminatorPropertyLiterals(normalized, branch, propertyName) {
+  const resolved = resolveSchema(normalized, branch);
+  const property = resolved?.properties?.[propertyName];
+  if (!property) return [];
+  const propertySchema = resolveSchema(normalized, property) ?? property;
+  const values = propertySchema.enum ?? (hasConst(propertySchema) ? [propertySchema.const] : []);
+  return values.filter((value) => typeof value === "string");
+}
+function resolveDiscriminatedUnion(normalized, schema) {
+  const branches = schema.oneOf ?? schema.anyOf;
+  if (!branches || branches.length === 0) return null;
+  const info = getDiscriminatorInfo(schema);
+  if (!info) return null;
+  if (!branches.every((branch) => isObjectSchemaBranch(normalized, branch))) return null;
+  const resolved = [];
+  for (const branch of branches) {
+    const literal = discriminatorLiteral(normalized, info, branch);
+    if (literal === null) return null;
+    resolved.push({ schema: branch, literal });
+  }
+  return { propertyName: info.propertyName, branches: resolved };
+}
 function isObjectSchemaBranch(normalized, branch) {
   const resolved = branch.$ref ? resolveSchema(normalized, branch) : branch;
   if (!resolved) return false;
@@ -1396,7 +1458,9 @@ function getHeaderParams(operation) {
   return (operation?.parameters ?? []).filter((parameter) => parameter.in === "header");
 }
 function getOperationParams(operation) {
-  return (operation?.parameters ?? []).filter((parameter) => parameter.in === "path" || parameter.in === "query" || parameter.in === "header");
+  return (operation?.parameters ?? []).filter(
+    (parameter) => parameter.in === "path" || parameter.in === "query" || parameter.in === "header"
+  );
 }
 function getCollectionParams(resource) {
   const params = [
@@ -1419,18 +1483,25 @@ function resolveSchema(normalized, schema) {
   if (!schema) return null;
   if (!schema.$ref) return schema;
   const name = schema.$ref.split("/").at(-1);
-  return normalized.schemas.find((candidate) => candidate.name === name || toSafeTypeName(candidate.name) === toSafeTypeName(name ?? ""))?.schema ?? schema;
+  return normalized.schemas.find(
+    (candidate) => candidate.name === name || toSafeTypeName(candidate.name) === toSafeTypeName(name ?? "")
+  )?.schema ?? schema;
 }
 function resolveSchemaName(schema) {
   if (!schema?.$ref) return null;
   return toSafeTypeName(schema.$ref.split("/").at(-1) ?? "");
 }
 function createSchemaDeclaration(normalized, name, schema, enumAliases) {
+  const nullableSuffix = schema.nullable ? " | null" : "";
   if (schema.oneOf?.length || schema.anyOf?.length) {
-    return `export type ${name} = ${schemaToTypeScript(normalized, schema, { mode: "response" })}`;
+    return `export type ${name} = ${schemaToTypeScript(normalized, schema, { mode: "response" })}${nullableSuffix}`;
   }
   if (isPureDictionarySchema(schema)) {
-    return `export type ${name} = ${createDictionaryType(normalized, schema.additionalProperties, { mode: "response" })}`;
+    return `export type ${name} = ${createDictionaryType(normalized, schema.additionalProperties, { mode: "response" })}${nullableSuffix}`;
+  }
+  const isScalarOrEnumDeclaration = schema.enum !== void 0 || hasConst(schema) || Array.isArray(schema.type) || typeof schema.type === "string" && schema.type !== "object";
+  if (isScalarOrEnumDeclaration) {
+    return `export type ${name} = ${schemaToTypeScript(normalized, schema, { mode: "response" })}${nullableSuffix}`;
   }
   const mode = name.endsWith("Dto") ? "request" : "response";
   const required = new Set(schema.required ?? []);
@@ -1444,7 +1515,13 @@ function createSchemaDeclaration(normalized, name, schema, enumAliases) {
     const nullable = property.nullable ? " | null" : "";
     return `  ${quoteObjectKeyIfNeeded(propertyName)}${optional}: ${baseType}${nullable}`;
   });
-  const indexSignature = createAdditionalPropertiesIndex(normalized, schema, { mode, indent: 0 }, "  ", required);
+  const indexSignature = createAdditionalPropertiesIndex(
+    normalized,
+    schema,
+    { mode, indent: 0 },
+    "  ",
+    required
+  );
   if (indexSignature) lines.push(indexSignature);
   return `export interface ${name} {
 ${lines.join("\n")}
@@ -1457,11 +1534,13 @@ function isPureDictionarySchema(schema) {
 }
 function createDictionaryType(normalized, additionalProperties, options) {
   if (additionalProperties === false) return "Record<string, never>";
-  if (additionalProperties === true || additionalProperties === void 0) return "Record<string, unknown>";
+  if (additionalProperties === true || additionalProperties === void 0)
+    return "Record<string, unknown>";
   return `Record<string, ${schemaToTypeScript(normalized, additionalProperties, options)}>`;
 }
 function createAdditionalPropertiesIndex(normalized, schema, options, childIndent, required) {
-  if (schema.additionalProperties === void 0 || schema.additionalProperties === false || isPureDictionarySchema(schema)) return null;
+  if (schema.additionalProperties === void 0 || schema.additionalProperties === false || isPureDictionarySchema(schema))
+    return null;
   const valueTypes = /* @__PURE__ */ new Set();
   if (schema.additionalProperties === true) {
     valueTypes.add("unknown");
@@ -1492,14 +1571,36 @@ function createOperationAliases(normalized, resource) {
   const names = createResourceTypeNames(resource);
   const identityParams = getIdentityParams(resource);
   const idDeclaration = identityParams.length > 1 ? createParamsInterface(normalized, names.idType, identityParams) : `export type ${names.idType} = ${identityParams[0]?.schema ? schemaToTypeScript(normalized, identityParams[0].schema, { mode: "request" }) : "string"}`;
-  const listParams = createParamsInterface(normalized, names.listParamsType, getCollectionParams(resource));
-  const listResponse = createResponseDeclaration(normalized, names.listResponseType, resource.operations.list);
-  const detailResponse = createResponseType(normalized, resource.operations.detail, names.entityType);
+  const listParams = createParamsInterface(
+    normalized,
+    names.listParamsType,
+    getCollectionParams(resource)
+  );
+  const listResponse = createResponseDeclaration(
+    normalized,
+    names.listResponseType,
+    resource.operations.list
+  );
+  const detailResponse = createResponseType(
+    normalized,
+    resource.operations.detail,
+    names.entityType
+  );
   const createRequest = createRequestBodyType(normalized, resource.operations.create) ?? `Partial<${names.entityType}>`;
   const updateRequest = createRequestBodyType(normalized, resource.operations.update) ?? `Partial<${names.entityType}>`;
-  const createResponse = createResponseType(normalized, resource.operations.create, names.entityType);
-  const updateResponse = createResponseType(normalized, resource.operations.update, names.entityType);
-  const operationAliases = resource.operationsList.filter((operation) => operation.operationKind !== "unsupported-operation" && !Object.values(resource.operations).includes(operation)).map((operation) => createOperationAlias(normalized, operation));
+  const createResponse = createResponseType(
+    normalized,
+    resource.operations.create,
+    names.entityType
+  );
+  const updateResponse = createResponseType(
+    normalized,
+    resource.operations.update,
+    names.entityType
+  );
+  const operationAliases = resource.operationsList.filter(
+    (operation) => operation.operationKind !== "unsupported-operation" && !Object.values(resource.operations).includes(operation)
+  ).map((operation) => createOperationAlias(normalized, operation));
   return [
     idDeclaration,
     `export type ${names.detailResponseType} = ${detailResponse}`,
@@ -1517,13 +1618,18 @@ function createOperationAlias(normalized, operation) {
   const params = createParamsInterface(normalized, names.paramsType, getOperationParams(operation));
   const request = createRequestBodyType(normalized, operation) ?? "void";
   const response = createResponseType(normalized, operation, "unknown");
-  return [params, `export type ${names.requestType} = ${request}`, `export type ${names.responseType} = ${response}`].join("\n\n");
+  return [
+    params,
+    `export type ${names.requestType} = ${request}`,
+    `export type ${names.responseType} = ${response}`
+  ].join("\n\n");
 }
 function createRequestBodyType(normalized, operation) {
   if (!operation?.requestBodySchema) return null;
   if (operation.requestContentTypes.some(isMultipartContentType)) return "FormData";
   if (operation.requestContentTypes.some(isFormUrlEncodedContentType)) return "URLSearchParams";
-  if (operation.requestContentTypes.some(isBinaryContentType)) return "Blob | ArrayBuffer | ReadableStream";
+  if (operation.requestContentTypes.some(isBinaryContentType))
+    return "Blob | ArrayBuffer | ReadableStream";
   return resolveSchemaName(operation.requestBodySchema) ?? schemaToTypeScript(normalized, operation.requestBodySchema, { mode: "request" });
 }
 function isMultipartContentType(contentType) {
@@ -1618,9 +1724,9 @@ function isForgePlugin(value) {
 function collectDiagnostics(normalized, options = {}) {
   const diagnostics = [];
   const groupedParameters = /* @__PURE__ */ new Map();
-  const unsupportedSecuritySchemes = Object.entries(normalized.document.components?.securitySchemes ?? {}).filter(
-    ([, scheme]) => !isRuntimeSupportedSecurityScheme(scheme)
-  );
+  const unsupportedSecuritySchemes = Object.entries(
+    normalized.document.components?.securitySchemes ?? {}
+  ).filter(([, scheme]) => !isRuntimeSupportedSecurityScheme(scheme));
   if (unsupportedSecuritySchemes.length > 0) {
     diagnostics.push({
       severity: "warning",
@@ -1633,7 +1739,9 @@ function collectDiagnostics(normalized, options = {}) {
   for (const operation of normalized.operations) {
     const location = `${operation.method.toUpperCase()} ${operation.path}`;
     const requestContentTypes = getContentTypes(operation.operation.requestBody);
-    const responseContentTypes = Object.values(operation.operation.responses ?? {}).flatMap((response) => Object.keys(response.content ?? {}));
+    const responseContentTypes = Object.values(operation.operation.responses ?? {}).flatMap(
+      (response) => Object.keys(response.content ?? {})
+    );
     if (operation.operationKind === "unsupported-operation") {
       diagnostics.push({
         severity: "warning",
@@ -1666,15 +1774,16 @@ function collectDiagnostics(normalized, options = {}) {
     }
     for (const parameter of operation.parameters) {
       if (parameter.in === "header" || parameter.in === "cookie") {
-        if (parameter.in === "header" && parameter.name.toLowerCase() === "authorization") {
-          continue;
-        }
-        if (parameter.in === "header" && operation.operationKind !== "crud-resource" && parameter.name.toLowerCase() !== "authorization") {
+        if (parameter.in === "header") {
           continue;
         }
         if (parameter.in === "cookie" && parameter.name.toLowerCase() === "authorization") {
           const key = `${parameter.in}:${parameter.name.toLowerCase()}`;
-          const grouped = groupedParameters.get(key) ?? { in: parameter.in, name: parameter.name, locations: [] };
+          const grouped = groupedParameters.get(key) ?? {
+            in: parameter.in,
+            name: parameter.name,
+            locations: []
+          };
           grouped.locations.push(location);
           groupedParameters.set(key, grouped);
           continue;
@@ -1713,7 +1822,12 @@ function collectDiagnostics(normalized, options = {}) {
   const schemaDiagnostics = [];
   for (const schema of normalized.schemas) {
     const originalSchema = normalized.document.components?.schemas?.[schema.name] ?? schema.schema;
-    collectSchemaDiagnostics(normalized, originalSchema, `#/components/schemas/${schema.name}`, schemaDiagnostics);
+    collectSchemaDiagnostics(
+      normalized,
+      originalSchema,
+      `#/components/schemas/${schema.name}`,
+      schemaDiagnostics
+    );
   }
   diagnostics.push(...schemaDiagnostics);
   diagnostics.push(...runPluginDiagnostics({ plugins: options.plugins, normalized }));
@@ -1780,7 +1894,8 @@ function isSupportedDiscriminatedUnion(normalized, schema) {
 function isRuntimeSupportedSecurityScheme(value) {
   if (!value || typeof value !== "object") return false;
   const scheme = value;
-  if (scheme.type === "http" && typeof scheme.scheme === "string" && scheme.scheme.toLowerCase() === "bearer") return true;
+  if (scheme.type === "http" && typeof scheme.scheme === "string" && scheme.scheme.toLowerCase() === "bearer")
+    return true;
   if (scheme.type === "oauth2") return true;
   return scheme.type === "apiKey" && scheme.in === "header";
 }
@@ -1796,10 +1911,19 @@ function isJsonCompatibleContentType(contentType) {
 function createSchemaCoverageMatrix(normalized, diagnostics) {
   const operations = normalized.operations;
   const unsupportedConstructs = countUnsupportedSchemaConstructs(normalized);
-  const operationDiagnosticOnly = operations.filter((operation) => operation.operationKind === "unsupported-operation").length;
-  const schemaDiagnosticOnly = Object.values(unsupportedConstructs).reduce((total, count) => total + count, 0);
-  const generated = operations.filter((operation) => operation.operationKind !== "unsupported-operation").length;
-  const fallback = operations.filter(hasFallbackShape).length + diagnostics.filter((diagnostic) => diagnostic.code === "missing-request-schema" || diagnostic.code === "missing-response-schema").length;
+  const operationDiagnosticOnly = operations.filter(
+    (operation) => operation.operationKind === "unsupported-operation"
+  ).length;
+  const schemaDiagnosticOnly = Object.values(unsupportedConstructs).reduce(
+    (total, count) => total + count,
+    0
+  );
+  const generated = operations.filter(
+    (operation) => operation.operationKind !== "unsupported-operation"
+  ).length;
+  const fallback = operations.filter(hasFallbackShape).length + diagnostics.filter(
+    (diagnostic) => diagnostic.code === "missing-request-schema" || diagnostic.code === "missing-response-schema"
+  ).length;
   return {
     operations: {
       total: operations.length,
@@ -1833,7 +1957,9 @@ function mergeSchemaCoverageMatrices(matrices) {
     },
     schemas: {
       total: sum(matrices, (matrix) => matrix.schemas.total),
-      unsupportedConstructs: mergeRecords(matrices.map((matrix) => matrix.schemas.unsupportedConstructs))
+      unsupportedConstructs: mergeRecords(
+        matrices.map((matrix) => matrix.schemas.unsupportedConstructs)
+      )
     },
     cases: {
       generated: sum(matrices, (matrix) => matrix.cases.generated),
@@ -1873,18 +1999,28 @@ function countUnsupportedSchemaConstructs(normalized) {
   return counts;
 }
 function visitSchema(normalized, schema, counts) {
-  if (schema.allOf) counts.allOf = (counts.allOf ?? 0) + 1;
-  if (schema.oneOf && !isSupportedUnion(normalized, schema, schema.oneOf)) counts.oneOf = (counts.oneOf ?? 0) + 1;
-  if (schema.anyOf && !isSupportedUnion(normalized, schema, schema.anyOf)) counts.anyOf = (counts.anyOf ?? 0) + 1;
+  if (schema.allOf && !unwrapAnnotationOnlyAllOfSchema(schema)) {
+    if (analyzeAllOfSchema(normalized.document, schema).kind !== "mergeable")
+      counts.allOf = (counts.allOf ?? 0) + 1;
+  }
+  if (schema.oneOf && !isSupportedUnion(normalized, schema, schema.oneOf))
+    counts.oneOf = (counts.oneOf ?? 0) + 1;
+  if (schema.anyOf && !isSupportedUnion(normalized, schema, schema.anyOf))
+    counts.anyOf = (counts.anyOf ?? 0) + 1;
   const union = schema.oneOf ?? schema.anyOf;
-  if (schema.discriminator && !(union && isSupportedUnion(normalized, schema, union))) counts.discriminator = (counts.discriminator ?? 0) + 1;
+  if (schema.discriminator && !(union && isSupportedUnion(normalized, schema, union)))
+    counts.discriminator = (counts.discriminator ?? 0) + 1;
   for (const property of Object.values(schema.properties ?? {})) {
     visitSchema(normalized, property, counts);
   }
   if (schema.items) {
     visitSchema(normalized, schema.items, counts);
   }
-  for (const branch of [...schema.allOf ?? [], ...schema.oneOf ?? [], ...schema.anyOf ?? []]) {
+  for (const branch of [
+    ...schema.allOf ?? [],
+    ...schema.oneOf ?? [],
+    ...schema.anyOf ?? []
+  ]) {
     visitSchema(normalized, branch, counts);
   }
 }
@@ -2130,7 +2266,10 @@ function createClientArtifact(normalized, resourceName2, resource) {
     const pathParams = getPathParams(resource.operations.list);
     const queryParams = getQueryParams(resource.operations.list);
     const requiresParams = pathParams.length > 0;
-    signatures.push(`  ${resource.operations.list.id}: (params${requiresParams ? "" : "?"}: ${names.listParamsType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+    const listOptions = crudOptionsType(resource.operations.list, requestOptionsType);
+    signatures.push(
+      `  ${resource.operations.list.id}: (params${requiresParams ? "" : "?"}: ${names.listParamsType}, ${optionsParam(listOptions)}) => Promise<${response}>`
+    );
     implementations.push(
       `  ${resource.operations.list.id}: (params, options) => apiClient.request<${response}>('GET', ${pathWithParamsObject(resource.operations.list.path)}${createListRequestOptions(queryParams, requiresParams)}),`
     );
@@ -2140,7 +2279,9 @@ function createClientArtifact(normalized, resourceName2, resource) {
     const pathParams = getPathParams(resource.operations.detail);
     const paramSignature = createPathParamSignature(pathParams, names.idType);
     const paramName = pathParams.length > 1 ? "params" : toSafeIdentifier(pathParams[0]?.name ?? "id");
-    signatures.push(`  ${resource.operations.detail.id}: (${paramName}: ${paramSignature}, options?: ${requestOptionsType}) => Promise<${response}>`);
+    signatures.push(
+      `  ${resource.operations.detail.id}: (${paramName}: ${paramSignature}, ${optionsParam(crudOptionsType(resource.operations.detail, requestOptionsType))}) => Promise<${response}>`
+    );
     implementations.push(
       `  ${resource.operations.detail.id}: (${paramName}, options) => apiClient.request<${response}>('GET', ${pathWithParams(resource.operations.detail.path, pathParams)}, options),`
     );
@@ -2149,12 +2290,16 @@ function createClientArtifact(normalized, resourceName2, resource) {
     const response = names.createResponseType;
     const pathParams = getPathParams(resource.operations.create);
     if (pathParams.length > 0) {
-      signatures.push(`  ${resource.operations.create.id}: (params: ${names.listParamsType}, payload: ${names.createRequestType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+      signatures.push(
+        `  ${resource.operations.create.id}: (params: ${names.listParamsType}, payload: ${names.createRequestType}, ${optionsParam(crudOptionsType(resource.operations.create, requestOptionsType))}) => Promise<${response}>`
+      );
       implementations.push(
         `  ${resource.operations.create.id}: (params, payload, options) => apiClient.request<${response}>('POST', ${pathWithParamsObject(resource.operations.create.path)}, { ...options, body: payload }),`
       );
     } else {
-      signatures.push(`  ${resource.operations.create.id}: (payload: ${names.createRequestType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+      signatures.push(
+        `  ${resource.operations.create.id}: (payload: ${names.createRequestType}, ${optionsParam(crudOptionsType(resource.operations.create, requestOptionsType))}) => Promise<${response}>`
+      );
       implementations.push(
         `  ${resource.operations.create.id}: (payload, options) => apiClient.request<${response}>('POST', '${resource.operations.create.path}', { ...options, body: payload }),`
       );
@@ -2165,7 +2310,9 @@ function createClientArtifact(normalized, resourceName2, resource) {
     const pathParams = getPathParams(resource.operations.update);
     const paramSignature = createPathParamSignature(pathParams, names.idType);
     const paramName = pathParams.length > 1 ? "params" : toSafeIdentifier(pathParams[0]?.name ?? "id");
-    signatures.push(`  ${resource.operations.update.id}: (${paramName}: ${paramSignature}, payload: ${names.updateRequestType}, options?: ${requestOptionsType}) => Promise<${response}>`);
+    signatures.push(
+      `  ${resource.operations.update.id}: (${paramName}: ${paramSignature}, payload: ${names.updateRequestType}, ${optionsParam(crudOptionsType(resource.operations.update, requestOptionsType))}) => Promise<${response}>`
+    );
     implementations.push(
       `  ${resource.operations.update.id}: (${paramName}, payload, options) => apiClient.request<${response}>('PATCH', ${pathWithParams(resource.operations.update.path, pathParams)}, { ...options, body: payload }),`
     );
@@ -2174,12 +2321,16 @@ function createClientArtifact(normalized, resourceName2, resource) {
     const pathParams = getPathParams(resource.operations.delete);
     const paramSignature = createPathParamSignature(pathParams, names.idType);
     const paramName = pathParams.length > 1 ? "params" : toSafeIdentifier(pathParams[0]?.name ?? "id");
-    signatures.push(`  ${resource.operations.delete.id}: (${paramName}: ${paramSignature}, options?: ${requestOptionsType}) => Promise<void>`);
+    signatures.push(
+      `  ${resource.operations.delete.id}: (${paramName}: ${paramSignature}, ${optionsParam(crudOptionsType(resource.operations.delete, requestOptionsType))}) => Promise<void>`
+    );
     implementations.push(
       `  ${resource.operations.delete.id}: (${paramName}, options) => apiClient.request<void>('DELETE', ${pathWithParams(resource.operations.delete.path, pathParams)}, options),`
     );
   }
-  for (const operation of resource.operationsList.filter((item) => isGeneratedOperation(resource, item))) {
+  for (const operation of resource.operationsList.filter(
+    (item) => isGeneratedOperation(resource, item)
+  )) {
     const names2 = createOperationTypeNames(operation);
     const response = names2.responseType;
     const params = getOperationParams(operation);
@@ -2187,15 +2338,26 @@ function createClientArtifact(normalized, resourceName2, resource) {
     const headerParams = getHeaderParams(operation);
     const method = operation.method.toUpperCase();
     const pathExpression = pathWithOperationParams(operation.path);
-    const options = createOperationRequestOptions(operation.requestBodySchema ? "payload" : null, queryParams, headerParams);
-    signatures.push(`  ${operation.id}: ${createOperationSignature(names2, Boolean(operation.requestBodySchema), params.length > 0, response, requestOptionsType)}`);
-    implementations.push(`  ${operation.id}: ${createOperationImplementationArgs(Boolean(operation.requestBodySchema), params.length > 0)} => apiClient.request<${response}>('${method}', ${pathExpression}${options}),`);
+    const options = createOperationRequestOptions(
+      operation.requestBodySchema ? "payload" : null,
+      queryParams,
+      headerParams
+    );
+    signatures.push(
+      `  ${operation.id}: ${createOperationSignature(names2, Boolean(operation.requestBodySchema), params.length > 0, response, requestOptionsType)}`
+    );
+    implementations.push(
+      `  ${operation.id}: ${createOperationImplementationArgs(Boolean(operation.requestBodySchema), params.length > 0)} => apiClient.request<${response}>('${method}', ${pathExpression}${options}),`
+    );
   }
   const imports = collectClientTypes(resource);
   const typeImport = imports.length > 0 ? `import type { ${imports.join(", ")} } from './${resourceName2}.types'
 
 ` : "";
-  const runtimeImports = ["createApiClient", ...usesQueryParamWrapper(resource) ? ["queryParam"] : []];
+  const runtimeImports = [
+    "createApiClient",
+    ...usesQueryParamWrapper(resource) ? ["queryParam"] : []
+  ];
   const entityCollectionName = pluralizeTypeName(resource.entity);
   const configureName = `configure${entityCollectionName}Client`;
   const setName = `set${entityCollectionName}Client`;
@@ -2233,14 +2395,16 @@ function collectClientTypes(resource) {
   const types = /* @__PURE__ */ new Set();
   if (resource.operations.list?.id) {
     types.add(names.listParamsType);
-    if (resource.operations.list.responseSchema || resource.operations.list.responseBodyEmpty) types.add(names.listResponseType);
+    if (resource.operations.list.responseSchema || resource.operations.list.responseBodyEmpty)
+      types.add(names.listResponseType);
   }
   if (resource.operations.detail?.id) {
     types.add(names.idType);
     types.add(names.detailResponseType);
   }
   if (resource.operations.create?.id) {
-    if (!resource.operations.list?.id && getPathParams(resource.operations.create).length > 0) types.add(names.listParamsType);
+    if (!resource.operations.list?.id && getPathParams(resource.operations.create).length > 0)
+      types.add(names.listParamsType);
     types.add(names.createRequestType);
     types.add(names.createResponseType);
   }
@@ -2252,7 +2416,9 @@ function collectClientTypes(resource) {
   if (resource.operations.delete?.id) {
     types.add(names.idType);
   }
-  for (const operation of resource.operationsList.filter((item) => isGeneratedOperation(resource, item))) {
+  for (const operation of resource.operationsList.filter(
+    (item) => isGeneratedOperation(resource, item)
+  )) {
     const operationNames = createOperationTypeNames(operation);
     if (getOperationParams(operation).length > 0) types.add(operationNames.paramsType);
     if (operation.requestBodySchema) types.add(operationNames.requestType);
@@ -2276,10 +2442,29 @@ function pathWithParamsObject(path) {
 function isGeneratedOperation(resource, operation) {
   return operation.operationKind !== "unsupported-operation" && Boolean(operation.id) && !Object.values(resource.operations).includes(operation);
 }
+function typedHeaderParams(operation) {
+  return getHeaderParams(operation).filter(
+    (parameter) => parameter.name.toLowerCase() !== "authorization"
+  );
+}
+function crudOptionsType(operation, baseType) {
+  const headers = typedHeaderParams(operation);
+  if (headers.length === 0) return baseType;
+  const entries = headers.map(
+    (parameter) => `${quoteObjectKeyIfNeeded(parameter.name)}${parameter.required ? "" : "?"}: string`
+  ).join("; ");
+  return `${baseType} & { headers: { ${entries} } & Record<string, string> }`;
+}
+function optionsParam(optionsType) {
+  return `options?: ${optionsType}`;
+}
 function createOperationSignature(names, hasPayload, hasParams, response, requestOptionsType) {
-  if (hasPayload && hasParams) return `(payload: ${names.requestType}, params: ${names.paramsType}, options?: ${requestOptionsType}) => Promise<${response}>`;
-  if (hasPayload) return `(payload: ${names.requestType}, options?: ${requestOptionsType}) => Promise<${response}>`;
-  if (hasParams) return `(params: ${names.paramsType}, options?: ${requestOptionsType}) => Promise<${response}>`;
+  if (hasPayload && hasParams)
+    return `(payload: ${names.requestType}, params: ${names.paramsType}, options?: ${requestOptionsType}) => Promise<${response}>`;
+  if (hasPayload)
+    return `(payload: ${names.requestType}, options?: ${requestOptionsType}) => Promise<${response}>`;
+  if (hasParams)
+    return `(params: ${names.paramsType}, options?: ${requestOptionsType}) => Promise<${response}>`;
   return `(options?: ${requestOptionsType}) => Promise<${response}>`;
 }
 function createOperationImplementationArgs(hasPayload, hasParams) {
@@ -2296,13 +2481,16 @@ function createOperationRequestOptions(payloadName, queryParams, headerParams) {
     options.push(`params: ${createQueryParamsObject(queryParams, false)}`);
   }
   if (headerParams.length > 0) {
-    options.push(`headers: createOperationHeaders(options?.headers, { ${headerParams.map((param) => `${quoteObjectKeyIfNeeded(param.name)}: ${paramValueAccess("params", param.name)}`).join(", ")} })`);
+    options.push(
+      `headers: createOperationHeaders(options?.headers, { ${headerParams.map((param) => `${quoteObjectKeyIfNeeded(param.name)}: ${paramValueAccess("params", param.name)}`).join(", ")} })`
+    );
   }
   return options.length > 1 ? `, { ${options.join(", ")} }` : ", options";
 }
 function createListRequestOptions(queryParams, requiresParams) {
   if (queryParams.length === 0) return ", options";
-  if (!requiresParams && !queryParams.some(requiresQueryParamWrapper)) return ", { ...options, params: params as Record<string, unknown> | undefined }";
+  if (!requiresParams && !queryParams.some(requiresQueryParamWrapper))
+    return ", { ...options, params: params as Record<string, unknown> | undefined }";
   return `, { ...options, params: ${createQueryParamsObject(queryParams, !requiresParams)} }`;
 }
 function pathWithOperationParams(path) {
@@ -2330,7 +2518,9 @@ function requiresQueryParamWrapper(param) {
   return param.in === "query" && param.schema?.type === "array" && (param.style ?? "form") === "form" && param.explode === false;
 }
 function usesQueryParamWrapper(resource) {
-  return resource.operationsList.some((operation) => getQueryParams(operation).some(requiresQueryParamWrapper));
+  return resource.operationsList.some(
+    (operation) => getQueryParams(operation).some(requiresQueryParamWrapper)
+  );
 }
 function createFixturesArtifact(resourceName2, entity) {
   return `export const ${resourceName2}Fixtures: ${entity}Fixture[] = []
@@ -2460,17 +2650,35 @@ function schemaToZod(normalized, schema, resolvingRefs = []) {
     return appendNullable("z.unknown()", resolved);
   }
   if (resolved.oneOf?.length || resolved.anyOf?.length) {
-    return appendNullable(createZodUnion(normalized, resolved.oneOf ?? resolved.anyOf ?? [], resolvingRefs), resolved);
+    const discriminated = resolveDiscriminatedUnion(normalized, resolved);
+    if (discriminated) {
+      return appendNullable(
+        createZodDiscriminatedUnion(normalized, discriminated, resolvingRefs),
+        resolved
+      );
+    }
+    return appendNullable(
+      createZodUnion(normalized, resolved.oneOf ?? resolved.anyOf ?? [], resolvingRefs),
+      resolved
+    );
   }
-  if (hasConst2(resolved)) return appendNullable(`z.literal(${JSON.stringify(resolved.const)})`, resolved);
+  if (hasConst2(resolved))
+    return appendNullable(`z.literal(${JSON.stringify(resolved.const)})`, resolved);
   if (resolved.enum?.length) return appendNullable(createZodEnum(resolved.enum), resolved);
   if (resolved.type === "string") return zodString(resolved);
   if (resolved.type === "integer") return appendNullable("z.number().int()", resolved);
   if (resolved.type === "number") return appendNullable(zodNumber(resolved), resolved);
   if (resolved.type === "boolean") return appendNullable("z.boolean()", resolved);
-  if (resolved.type === "array") return appendNullable(`z.array(${schemaToZod(normalized, resolved.items, resolvingRefs)})`, resolved);
+  if (resolved.type === "array")
+    return appendNullable(
+      `z.array(${schemaToZod(normalized, resolved.items, resolvingRefs)})`,
+      resolved
+    );
   if (isPureDictionarySchema2(resolved)) {
-    return appendNullable(`z.record(z.string(), ${schemaToZodRecordValue(normalized, resolved.additionalProperties, resolvingRefs)})`, resolved);
+    return appendNullable(
+      `z.record(z.string(), ${schemaToZodRecordValue(normalized, resolved.additionalProperties, resolvingRefs)})`,
+      resolved
+    );
   }
   if (resolved.type === "object" || resolved.properties) {
     const required = new Set(resolved.required ?? []);
@@ -2493,7 +2701,11 @@ function schemaToValibot(normalized, schema, resolvingRefs = []) {
     }
     const resolved2 = resolveSchema(normalized, schema);
     if (!resolved2 || resolved2 === schema) return wrapValibotNullable("v.unknown()", schema);
-    return schemaToValibot(normalized, resolved2, refName ? [...resolvingRefs, refName] : resolvingRefs);
+    return schemaToValibot(
+      normalized,
+      resolved2,
+      refName ? [...resolvingRefs, refName] : resolvingRefs
+    );
   }
   const resolved = resolveSchema(normalized, schema);
   if (!resolved) return "v.looseObject({})";
@@ -2503,19 +2715,41 @@ function schemaToValibot(normalized, schema, resolvingRefs = []) {
     return wrapValibotNullable("v.unknown()", resolved);
   }
   if (resolved.oneOf?.length || resolved.anyOf?.length) {
-    return wrapValibotNullable(createValibotUnion(normalized, resolved.oneOf ?? resolved.anyOf ?? [], resolvingRefs), resolved);
+    const discriminated = resolveDiscriminatedUnion(normalized, resolved);
+    if (discriminated) {
+      return wrapValibotNullable(
+        createValibotVariant(normalized, discriminated, resolvingRefs),
+        resolved
+      );
+    }
+    return wrapValibotNullable(
+      createValibotUnion(normalized, resolved.oneOf ?? resolved.anyOf ?? [], resolvingRefs),
+      resolved
+    );
   }
-  if (hasConst2(resolved)) return wrapValibotNullable(`v.literal(${JSON.stringify(resolved.const)})`, resolved);
+  if (hasConst2(resolved))
+    return wrapValibotNullable(`v.literal(${JSON.stringify(resolved.const)})`, resolved);
   if (resolved.enum?.length) {
-    return wrapValibotNullable(`v.picklist([${resolved.enum.map((value) => JSON.stringify(value)).join(", ")}])`, resolved);
+    return wrapValibotNullable(
+      `v.picklist([${resolved.enum.map((value) => JSON.stringify(value)).join(", ")}])`,
+      resolved
+    );
   }
   if (resolved.type === "string") return valibotString(resolved);
-  if (resolved.type === "integer") return wrapValibotNullable("v.pipe(v.number(), v.integer())", resolved);
+  if (resolved.type === "integer")
+    return wrapValibotNullable("v.pipe(v.number(), v.integer())", resolved);
   if (resolved.type === "number") return wrapValibotNullable(valibotNumber(resolved), resolved);
   if (resolved.type === "boolean") return wrapValibotNullable("v.boolean()", resolved);
-  if (resolved.type === "array") return wrapValibotNullable(`v.array(${schemaToValibot(normalized, resolved.items, resolvingRefs)})`, resolved);
+  if (resolved.type === "array")
+    return wrapValibotNullable(
+      `v.array(${schemaToValibot(normalized, resolved.items, resolvingRefs)})`,
+      resolved
+    );
   if (isPureDictionarySchema2(resolved)) {
-    return wrapValibotNullable(`v.record(v.string(), ${schemaToValibotRecordValue(normalized, resolved.additionalProperties, resolvingRefs)})`, resolved);
+    return wrapValibotNullable(
+      `v.record(v.string(), ${schemaToValibotRecordValue(normalized, resolved.additionalProperties, resolvingRefs)})`,
+      resolved
+    );
   }
   if (resolved.type === "object" || resolved.properties) {
     const required = new Set(resolved.required ?? []);
@@ -2530,6 +2764,47 @@ ${fields}
   }
   return wrapValibotNullable("v.unknown()", resolved);
 }
+function createZodDiscriminatedUnion(normalized, discriminated, resolvingRefs) {
+  const branches = discriminated.branches.map(
+    (branch) => discriminatedBranch(normalized, branch, discriminated.propertyName, resolvingRefs, {
+      object: (fields) => `z.object({
+${fields}
+})`,
+      literal: (value) => `z.literal(${JSON.stringify(value)})`,
+      optional: (expression) => `${expression}.optional()`,
+      render: schemaToZod
+    })
+  );
+  return `z.discriminatedUnion(${JSON.stringify(discriminated.propertyName)}, [${branches.join(", ")}])`;
+}
+function createValibotVariant(normalized, discriminated, resolvingRefs) {
+  const branches = discriminated.branches.map(
+    (branch) => discriminatedBranch(normalized, branch, discriminated.propertyName, resolvingRefs, {
+      object: (fields) => `v.object({
+${fields}
+})`,
+      literal: (value) => `v.literal(${JSON.stringify(value)})`,
+      optional: (expression) => `v.optional(${expression})`,
+      render: schemaToValibot
+    })
+  );
+  return `v.variant(${JSON.stringify(discriminated.propertyName)}, [${branches.join(", ")}])`;
+}
+function discriminatedBranch(normalized, branch, propertyName, resolvingRefs, emit) {
+  const resolved = resolveSchema(normalized, branch.schema);
+  if (!resolved || resolved.type !== "object" && !resolved.properties) {
+    return emit.render(normalized, branch.schema, resolvingRefs);
+  }
+  const refName = resolveSchemaName(branch.schema);
+  const branchRefs = refName ? [...resolvingRefs, refName] : resolvingRefs;
+  const required = new Set(resolved.required ?? []);
+  const fields = Object.entries(resolved.properties ?? {}).map(([name, property]) => {
+    const rendered = name === propertyName ? emit.literal(branch.literal) : emit.render(normalized, property, branchRefs);
+    const value = required.has(name) ? rendered : emit.optional(rendered);
+    return `  ${toCodeKey(name)}: ${value},`;
+  }).join("\n");
+  return emit.object(fields);
+}
 function zodString(schema) {
   let expression = "z.string()";
   if (schema.format === "email") expression += ".email()";
@@ -3813,21 +4088,58 @@ function dedupeDiagnostics(diagnostics) {
 }
 
 // ../adapters/dist/index.js
-var tanstackQueryComposables = createQueryComposables("@tanstack/react-query");
-var vueQueryComposables = createQueryComposables("@tanstack/vue-query");
+var reactQueryHooks = {
+  queryHook: "useQuery",
+  mutationHook: "useMutation",
+  queryOptions: "UseQueryOptions",
+  mutationOptions: "UseMutationOptions",
+  queryClientHook: "useQueryClient",
+  optionsAsFunction: false
+};
+var QUERY_PROFILES = {
+  "tanstack-query": { module: "@tanstack/react-query", ...reactQueryHooks },
+  "vue-query": { module: "@tanstack/vue-query", ...reactQueryHooks },
+  "svelte-query": {
+    module: "@tanstack/svelte-query",
+    queryHook: "createQuery",
+    mutationHook: "createMutation",
+    queryOptions: "CreateQueryOptions",
+    mutationOptions: "CreateMutationOptions",
+    queryClientHook: "useQueryClient",
+    optionsAsFunction: false
+  },
+  "angular-query": {
+    module: "@tanstack/angular-query-experimental",
+    queryHook: "injectQuery",
+    mutationHook: "injectMutation",
+    queryOptions: "CreateQueryOptions",
+    mutationOptions: "CreateMutationOptions",
+    queryClientHook: "injectQueryClient",
+    optionsAsFunction: true
+  }
+};
+var tanstackQueryComposables = createQueryComposables("tanstack-query");
+var vueQueryComposables = createQueryComposables("vue-query");
+var svelteQueryComposables = createQueryComposables("svelte-query");
+var angularQueryComposables = createQueryComposables("angular-query");
+var COMPOSABLES_BY_TARGET = {
+  "tanstack-query": tanstackQueryComposables,
+  "vue-query": vueQueryComposables,
+  "svelte-query": svelteQueryComposables,
+  "angular-query": angularQueryComposables
+};
 function resolveQueryComposables(target) {
-  if (target === "tanstack-query") return tanstackQueryComposables;
-  if (target === "vue-query") return vueQueryComposables;
-  return void 0;
+  return target && target in COMPOSABLES_BY_TARGET ? COMPOSABLES_BY_TARGET[target] : void 0;
 }
-function createQueryComposables(queryModule) {
+function createQueryComposables(target) {
+  const profile = typeof target === "string" ? QUERY_PROFILES[target] : target;
   return {
-    list: (resourceName2, resource) => listHook(queryModule, resourceName2, resource),
-    detail: (resourceName2, resource) => detailHook(queryModule, resourceName2, resource),
-    createMutation: (resourceName2, resource) => createMutationHook(queryModule, resourceName2, resource),
-    updateMutation: (resourceName2, resource) => updateMutationHook(queryModule, resourceName2, resource),
-    deleteMutation: (resourceName2, resource) => deleteMutationHook(queryModule, resourceName2, resource),
-    operation: (resourceName2, operation) => operationHook(queryModule, resourceName2, operation)
+    list: (resourceName2, resource) => listHook(profile, resourceName2, resource),
+    detail: (resourceName2, resource) => detailHook(profile, resourceName2, resource),
+    createMutation: (resourceName2, resource) => createMutationHook(profile, resourceName2, resource),
+    updateMutation: (resourceName2, resource) => updateMutationHook(profile, resourceName2, resource),
+    deleteMutation: (resourceName2, resource) => deleteMutationHook(profile, resourceName2, resource),
+    operation: (resourceName2, operation) => operationHook(profile, resourceName2, operation)
   };
 }
 function importPaths(resourceName2) {
@@ -3846,57 +4158,70 @@ function missingHook(name) {
 }
 `;
 }
+function callQuery(profile, hook, optionsLiteral) {
+  return profile.optionsAsFunction ? `${hook}(() => (${optionsLiteral}))` : `${hook}(${optionsLiteral})`;
+}
 function invalidateOnSuccess(invalidation, usesVariables) {
   const signature = usesVariables ? "(_data, variables)" : "()";
   return `onSuccess: ${signature} => {
       queryClient.invalidateQueries({ queryKey: ${invalidation} })
     },`;
 }
-function listHook(queryModule, resourceName2, resource) {
+function listHook(profile, resourceName2, resource) {
   const collection = pluralizeTypeName(resource.entity);
   if (!resource.operations.list?.id) return missingHook(`use${collection}Query`);
   const names = createResourceTypeNames(resource);
   const paths = importPaths(resourceName2);
   const requiresParams = getPathParams(resource.operations.list).length > 0;
-  return `import { useQuery, type UseQueryOptions } from '${queryModule}'
+  const call = callQuery(
+    profile,
+    profile.queryHook,
+    `{
+    queryKey: ${keysName(resourceName2)}.list(params),
+    queryFn: () => ${clientName(resourceName2)}.${resource.operations.list.id}(params),
+    ...options,
+  }`
+  );
+  return `import { ${profile.queryHook}, type ${profile.queryOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import { ${keysName(resourceName2)} } from '${paths.keys}'
 import type { ${names.listParamsType}, ${names.listResponseType} } from '${paths.types}'
 
 export function use${collection}Query(
   params${requiresParams ? "" : "?"}: ${names.listParamsType},
-  options?: Omit<UseQueryOptions<${names.listResponseType}>, 'queryKey' | 'queryFn'>,
+  options?: Omit<${profile.queryOptions}<${names.listResponseType}>, 'queryKey' | 'queryFn'>,
 ) {
-  return useQuery({
-    queryKey: ${keysName(resourceName2)}.list(params),
-    queryFn: () => ${clientName(resourceName2)}.${resource.operations.list.id}(params),
-    ...options,
-  })
+  return ${call}
 }
 `;
 }
-function detailHook(queryModule, resourceName2, resource) {
+function detailHook(profile, resourceName2, resource) {
   if (!resource.operations.detail?.id) return missingHook(`use${resource.entity}Query`);
   const names = createResourceTypeNames(resource);
   const paths = importPaths(resourceName2);
-  return `import { useQuery, type UseQueryOptions } from '${queryModule}'
+  const call = callQuery(
+    profile,
+    profile.queryHook,
+    `{
+    queryKey: ${keysName(resourceName2)}.detail(id),
+    queryFn: () => ${clientName(resourceName2)}.${resource.operations.detail.id}(id),
+    ...options,
+  }`
+  );
+  return `import { ${profile.queryHook}, type ${profile.queryOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import { ${keysName(resourceName2)} } from '${paths.keys}'
 import type { ${names.detailResponseType}, ${names.idType} } from '${paths.types}'
 
 export function use${resource.entity}Query(
   id: ${names.idType},
-  options?: Omit<UseQueryOptions<${names.detailResponseType}>, 'queryKey' | 'queryFn'>,
+  options?: Omit<${profile.queryOptions}<${names.detailResponseType}>, 'queryKey' | 'queryFn'>,
 ) {
-  return useQuery({
-    queryKey: ${keysName(resourceName2)}.detail(id),
-    queryFn: () => ${clientName(resourceName2)}.${resource.operations.detail.id}(id),
-    ...options,
-  })
+  return ${call}
 }
 `;
 }
-function createMutationHook(queryModule, resourceName2, resource) {
+function createMutationHook(profile, resourceName2, resource) {
   if (!resource.operations.create?.id) return missingHook(`useCreate${resource.entity}Mutation`);
   const names = createResourceTypeNames(resource);
   const paths = importPaths(resourceName2);
@@ -3905,70 +4230,84 @@ function createMutationHook(queryModule, resourceName2, resource) {
   const callArgs = hasPathParams ? "input.params, input.payload" : "input";
   const invalidation = hasPathParams ? `${keysName(resourceName2)}.list(variables.params)` : `${keysName(resourceName2)}.list()`;
   const typeImports = hasPathParams ? `${names.createRequestType}, ${names.createResponseType}, ${names.listParamsType}` : `${names.createRequestType}, ${names.createResponseType}`;
-  return `import { useMutation, useQueryClient, type UseMutationOptions } from '${queryModule}'
+  const call = callQuery(
+    profile,
+    profile.mutationHook,
+    `{
+    mutationFn: (input: ${inputType}) => ${clientName(resourceName2)}.${resource.operations.create.id}(${callArgs}),
+    ${invalidateOnSuccess(invalidation, hasPathParams)}
+    ...options,
+  }`
+  );
+  return `import { ${profile.mutationHook}, ${profile.queryClientHook}, type ${profile.mutationOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import { ${keysName(resourceName2)} } from '${paths.keys}'
 import type { ${typeImports} } from '${paths.types}'
 
 export function useCreate${resource.entity}Mutation(
-  options?: Omit<UseMutationOptions<${names.createResponseType}, Error, ${inputType}>, 'mutationFn'>,
+  options?: Omit<${profile.mutationOptions}<${names.createResponseType}, Error, ${inputType}>, 'mutationFn'>,
 ) {
-  const queryClient = useQueryClient()
-  return useMutation({
-    mutationFn: (input: ${inputType}) => ${clientName(resourceName2)}.${resource.operations.create.id}(${callArgs}),
-    ${invalidateOnSuccess(invalidation, hasPathParams)}
-    ...options,
-  })
+  const queryClient = ${profile.queryClientHook}()
+  return ${call}
 }
 `;
 }
-function updateMutationHook(queryModule, resourceName2, resource) {
+function updateMutationHook(profile, resourceName2, resource) {
   if (!resource.operations.update?.id) return missingHook(`useUpdate${resource.entity}Mutation`);
   const names = createResourceTypeNames(resource);
   const paths = importPaths(resourceName2);
   const inputType = `{ id: ${names.idType}; payload: ${names.updateRequestType} }`;
-  return `import { useMutation, useQueryClient, type UseMutationOptions } from '${queryModule}'
+  const call = callQuery(
+    profile,
+    profile.mutationHook,
+    `{
+    mutationFn: (input: ${inputType}) => ${clientName(resourceName2)}.${resource.operations.update.id}(input.id, input.payload),
+    ${invalidateOnSuccess(`${keysName(resourceName2)}.detail(variables.id)`, true)}
+    ...options,
+  }`
+  );
+  return `import { ${profile.mutationHook}, ${profile.queryClientHook}, type ${profile.mutationOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import { ${keysName(resourceName2)} } from '${paths.keys}'
 import type { ${names.idType}, ${names.updateRequestType}, ${names.updateResponseType} } from '${paths.types}'
 
 export function useUpdate${resource.entity}Mutation(
-  options?: Omit<UseMutationOptions<${names.updateResponseType}, Error, ${inputType}>, 'mutationFn'>,
+  options?: Omit<${profile.mutationOptions}<${names.updateResponseType}, Error, ${inputType}>, 'mutationFn'>,
 ) {
-  const queryClient = useQueryClient()
-  return useMutation({
-    mutationFn: (input: ${inputType}) => ${clientName(resourceName2)}.${resource.operations.update.id}(input.id, input.payload),
-    ${invalidateOnSuccess(`${keysName(resourceName2)}.detail(variables.id)`, true)}
-    ...options,
-  })
+  const queryClient = ${profile.queryClientHook}()
+  return ${call}
 }
 `;
 }
-function deleteMutationHook(queryModule, resourceName2, resource) {
+function deleteMutationHook(profile, resourceName2, resource) {
   if (!resource.operations.delete?.id) return missingHook(`useDelete${resource.entity}Mutation`);
   const names = createResourceTypeNames(resource);
   const paths = importPaths(resourceName2);
   const invalidatesDetail = getPathParams(resource.operations.delete).length > 1;
   const invalidation = invalidatesDetail ? `${keysName(resourceName2)}.detail(variables)` : `${keysName(resourceName2)}.list()`;
-  const onSuccess = invalidateOnSuccess(invalidation, invalidatesDetail);
-  return `import { useMutation, useQueryClient, type UseMutationOptions } from '${queryModule}'
+  const call = callQuery(
+    profile,
+    profile.mutationHook,
+    `{
+    mutationFn: (id: ${names.idType}) => ${clientName(resourceName2)}.${resource.operations.delete.id}(id),
+    ${invalidateOnSuccess(invalidation, invalidatesDetail)}
+    ...options,
+  }`
+  );
+  return `import { ${profile.mutationHook}, ${profile.queryClientHook}, type ${profile.mutationOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import { ${keysName(resourceName2)} } from '${paths.keys}'
 import type { ${names.idType} } from '${paths.types}'
 
 export function useDelete${resource.entity}Mutation(
-  options?: Omit<UseMutationOptions<void, Error, ${names.idType}>, 'mutationFn'>,
+  options?: Omit<${profile.mutationOptions}<void, Error, ${names.idType}>, 'mutationFn'>,
 ) {
-  const queryClient = useQueryClient()
-  return useMutation({
-    mutationFn: (id: ${names.idType}) => ${clientName(resourceName2)}.${resource.operations.delete.id}(id),
-    ${onSuccess}
-    ...options,
-  })
+  const queryClient = ${profile.queryClientHook}()
+  return ${call}
 }
 `;
 }
-function operationHook(queryModule, resourceName2, operation) {
+function operationHook(profile, resourceName2, operation) {
   const names = createOperationTypeNames(operation);
   const hookName = operationComposableName(operation);
   const paths = importPaths(resourceName2);
@@ -3985,34 +4324,44 @@ function operationHook(queryModule, resourceName2, operation) {
   ].join(", ");
   if (isQuery) {
     const keyEntries = hasInput ? `[...${keysName(resourceName2)}.all, '${operation.id}', input]` : `[...${keysName(resourceName2)}.all, '${operation.id}']`;
-    return `import { useQuery, type UseQueryOptions } from '${queryModule}'
+    const call2 = callQuery(
+      profile,
+      profile.queryHook,
+      `{
+    queryKey: ${keyEntries},
+    queryFn: () => ${clientName(resourceName2)}.${operation.id}(${callArgs}),
+    ...options,
+  }`
+    );
+    return `import { ${profile.queryHook}, type ${profile.queryOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import { ${keysName(resourceName2)} } from '${paths.keys}'
 import type { ${typeImports} } from '${paths.types}'
 
 export function ${hookName}(
 ${hasInput ? `  input: ${inputType},
-` : ""}  options?: Omit<UseQueryOptions<${names.responseType}>, 'queryKey' | 'queryFn'>,
+` : ""}  options?: Omit<${profile.queryOptions}<${names.responseType}>, 'queryKey' | 'queryFn'>,
 ) {
-  return useQuery({
-    queryKey: ${keyEntries},
-    queryFn: () => ${clientName(resourceName2)}.${operation.id}(${callArgs}),
-    ...options,
-  })
+  return ${call2}
 }
 `;
   }
-  return `import { useMutation, type UseMutationOptions } from '${queryModule}'
+  const call = callQuery(
+    profile,
+    profile.mutationHook,
+    `{
+    mutationFn: (${hasInput ? `input: ${inputType}` : ""}) => ${clientName(resourceName2)}.${operation.id}(${callArgs}),
+    ...options,
+  }`
+  );
+  return `import { ${profile.mutationHook}, type ${profile.mutationOptions} } from '${profile.module}'
 import { ${clientName(resourceName2)} } from '${paths.client}'
 import type { ${typeImports} } from '${paths.types}'
 
 export function ${hookName}(
-  options?: Omit<UseMutationOptions<${names.responseType}, Error, ${inputType}>, 'mutationFn'>,
+  options?: Omit<${profile.mutationOptions}<${names.responseType}, Error, ${inputType}>, 'mutationFn'>,
 ) {
-  return useMutation({
-    mutationFn: (${hasInput ? `input: ${inputType}` : ""}) => ${clientName(resourceName2)}.${operation.id}(${callArgs}),
-    ...options,
-  })
+  return ${call}
 }
 `;
 }

package/dist/index.js

@@ -29,7 +29,7 @@ import {
   summarizeFilePlan,
   writeGeneratedFiles,
   writeReportFile
-} from "./chunk-RL23SDLM.js";
+} from "./chunk-FSB2T27T.js";
 
 // src/index.ts
 import { cac } from "cac";

package/dist/internal.js

@@ -19,7 +19,7 @@ import {
   scanSourceUsages,
   validateLicenseKey,
   writeReportFile
-} from "./chunk-RL23SDLM.js";
+} from "./chunk-FSB2T27T.js";
 
 // src/git-base-schema.ts
 import { execFile } from "child_process";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archora/forge-cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "CLI for generating typed frontend resource contracts from OpenAPI contracts.",
   "license": "MIT",
   "repository": {
@@ -44,9 +44,9 @@
     "@types/node": "^22.15.17",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@archora/forge-adapters": "2.0.0",
-    "@archora/forge-config": "2.0.0",
-    "@archora/forge-core": "2.0.0"
+    "@archora/forge-adapters": "2.1.0",
+    "@archora/forge-config": "2.1.0",
+    "@archora/forge-core": "2.1.0"
   },
   "scripts": {
     "build": "tsup",