typed-openapi 2.2.4 → 2.2.6

package/dist/chunk-MAZKDIN3.js

@@ -0,0 +1,61 @@
+// src/format.ts
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+var defaultFilePath = "generated.ts";
+var require2 = createRequire(import.meta.url);
+async function formatWithBundledOxfmt(filePath, input, options) {
+  const packageJsonPath = require2.resolve("oxfmt/package.json");
+  const packageRoot = dirname(packageJsonPath);
+  const indexSource = await readFile(join(packageRoot, "dist", "index.js"), "utf8");
+  const match = indexSource.match(/from ["']\.\/(apis-[^"']+\.js)["']/);
+  const internalFile = match?.[1];
+  if (!internalFile) {
+    throw new Error("Unable to locate oxfmt's bundled JS formatter");
+  }
+  const internalUrl = pathToFileURL(join(packageRoot, "dist", internalFile)).href;
+  const { r: formatFile } = await import(internalUrl);
+  return formatFile({
+    code: input,
+    options: {
+      printWidth: 120,
+      trailingComma: "all",
+      ...options,
+      filepath: filePath
+    }
+  });
+}
+async function maybePretty(input, options) {
+  const { enabled, filePath = defaultFilePath, ...formatOptions } = options ?? {};
+  if (enabled === false) {
+    return input;
+  }
+  try {
+    const { format } = await import("oxfmt");
+    const result = await format(filePath, input, {
+      printWidth: 120,
+      trailingComma: "all",
+      ...formatOptions
+    });
+    if (result.errors.length > 0) {
+      console.warn(`Failed to format code in ${filePath}`);
+      console.warn(result.errors);
+      return input;
+    }
+    return result.code;
+  } catch {
+    try {
+      return await formatWithBundledOxfmt(filePath, input, formatOptions);
+    } catch (err) {
+      console.warn(`Failed to format code in ${filePath}`);
+      console.warn(err);
+      return input;
+    }
+  }
+}
+var prettify = (str, options) => maybePretty(str, options);
+
+export {
+  prettify
+};

package/dist/{chunk-ZM3UP6UJ.js → chunk-S3NICEHD.js}

@@ -1,7 +1,3 @@
-import {
-  prettify
-} from "./chunk-KAEXXJ7X.js";
-
 // src/asserts.ts
 var isPrimitiveType = (type2) => primitiveTypeList.includes(type2);
 var primitiveTypeList = ["string", "number", "integer", "boolean", "null"];
@@ -17,10 +13,10 @@ function normalizeString(text) {
   const prefixed = prefixStringStartingWithNumberIfNeeded(text);
   return prefixed.normalize("NFKD").trim().replace(/\s+/g, "_").replace(/-+/g, "_").replace(/[^\w\-]+/g, "_").replace(/--+/g, "-");
 }
-var onlyWordRegex = /^\w+$/;
+var barePropertyNameRegex = /^(?:[A-Za-z_]\w*|\d+)$/;
 var wrapWithQuotesIfNeeded = (str) => {
   if (str[0] === '"' && str[str.length - 1] === '"') return str;
-  if (onlyWordRegex.test(str)) {
+  if (barePropertyNameRegex.test(str)) {
     return str;
   }
   return `"${str}"`;
@@ -132,9 +128,9 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
     }
     if (schemaType === "object" || schema.properties || schema.additionalProperties) {
       if (!schema.properties) {
-        if (schema.additionalProperties && !isReferenceObject(schema.additionalProperties) && typeof schema.additionalProperties !== "boolean") {
+        if (schema.additionalProperties && typeof schema.additionalProperties !== "boolean") {
           const valueSchema = openApiSchemaToTs({ schema: schema.additionalProperties, ctx, meta });
-          return t.literal(`Record<string, ${valueSchema.value}>`);
+          return t.reference("Record", [t.string(), valueSchema]);
         }
         return t.literal("Record<string, unknown>");
       }
@@ -150,9 +146,7 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
             meta
           });
         }
-        additionalProperties = t.literal(
-          `Record<string, ${additionalPropertiesType ? additionalPropertiesType.value : t.any().value}>`
-        );
+        additionalProperties = t.reference("Record", [t.string(), additionalPropertiesType ?? t.any()]);
       }
       const hasRequiredArray = schema.required && schema.required.length > 0;
       const isPartial = !schema.required?.length;
@@ -171,9 +165,7 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
       return isPartial ? t.reference("Partial", [objectType]) : objectType;
     }
     if (!schemaType) {
-      const nullableKey = Object.keys(schema).filter(
-        (key) => !["nullable"].includes(key)
-      );
+      const nullableKey = Object.keys(schema).filter((key) => !["nullable"].includes(key));
       if (nullableKey.length === 0 && schema.nullable) {
         return t.literal("null");
       }
@@ -201,6 +193,7 @@ var Box = class _Box {
     this.schema = definition.schema;
     this.ctx = definition.ctx;
   }
+  definition;
   type;
   value;
   params;
@@ -386,13 +379,28 @@ var replacerByRuntime = {
     "$1$2("
   )
 };
+var shouldRenderDescriptionComments = (ctx) => ctx.jsdoc && ctx.runtime === "none";
+var escapeCommentText = (text) => text.replace(/\*\//g, "*\\/");
+var renderDescriptionComment = (description, indent = "") => {
+  const lines = description.trim().split(/\r?\n/);
+  return `${indent}/**
+${lines.map((line) => `${indent} * ${escapeCommentText(line)}`).join("\n")}
+${indent} */`;
+};
+var getSchemaDescription = (schema) => {
+  if (!schema || typeof schema !== "object") return void 0;
+  if ("description" in schema && typeof schema.description === "string") return schema.description;
+  return void 0;
+};
+var indentMultiline = (value, indent = "  ") => value.includes("\n") ? value.split("\n").map((line, index) => index === 0 ? line : `${indent}${line}`).join("\n") : value;
 var generateFile = (options) => {
   const ctx = {
     ...options,
     runtime: options.runtime ?? "none",
     successStatusCodes: options.successStatusCodes ?? DEFAULT_SUCCESS_STATUS_CODES,
     errorStatusCodes: options.errorStatusCodes ?? DEFAULT_ERROR_STATUS_CODES,
-    includeClient: options.includeClient ?? true
+    includeClient: options.includeClient ?? true,
+    jsdoc: options.jsdoc ?? false
   };
   const schemaList = generateSchemaList(ctx);
   const endpointSchemaList = options.schemasOnly ? "" : generateEndpointSchemaList(ctx);
@@ -422,7 +430,8 @@ var generateFile = (options) => {
   `;
   return file;
 };
-var generateSchemaList = ({ refs, runtime }) => {
+var generateSchemaList = (ctx) => {
+  const { refs, runtime } = ctx;
   let file = `
   ${runtime === "none" ? "export namespace Schemas {" : ""}
     // <Schemas>
@@ -430,7 +439,10 @@ var generateSchemaList = ({ refs, runtime }) => {
   refs.getOrderedSchemas().forEach(([schema, infos]) => {
     if (!infos?.name) return;
     if (infos.kind !== "schemas") return;
-    file += `export type ${infos.normalized} = ${schema.value}
+    const description = shouldRenderDescriptionComments(ctx) ? getSchemaDescription(schema.schema) : void 0;
+    const schemaValue = shouldRenderDescriptionComments(ctx) && !Box.isReference(schema) ? boxToString(schema, ctx, { prefixRefsWithSchemas: false }) : schema.value;
+    file += `${description ? `${renderDescriptionComment(description)}
+` : ""}export type ${infos.normalized} = ${schemaValue}
 `;
   });
   return file + `
@@ -438,29 +450,79 @@ var generateSchemaList = ({ refs, runtime }) => {
     ${runtime === "none" ? "}" : ""}
   `;
 };
+var boxToString = (box, ctx, options = {}) => {
+  const prefixRefsWithSchemas = options.prefixRefsWithSchemas ?? true;
+  if (ctx.runtime !== "none") {
+    return box.value;
+  }
+  const renderValue = (value) => {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (Box.isBox(value)) {
+      return boxToString(value, ctx, options);
+    }
+    return value.value;
+  };
+  if (Box.isUnion(box)) {
+    return `(${box.params.types.map((type2) => renderValue(type2)).join(" | ")})`;
+  }
+  if (Box.isIntersection(box)) {
+    return `(${box.params.types.map((type2) => renderValue(type2)).join(" & ")})`;
+  }
+  if (Box.isArray(box)) {
+    return `Array<${renderValue(box.params.type)}>`;
+  }
+  if (Box.isOptional(box)) {
+    return `${renderValue(box.params.type)} | undefined`;
+  }
+  if (Box.isObject(box)) {
+    const renderedProps = Object.entries(box.params.props).map(([prop, type2]) => {
+      const isOptional = typeof type2 !== "string" && Box.isBox(type2) && Box.isOptional(type2);
+      const renderedValue = indentMultiline(renderValue(type2));
+      const description = shouldRenderDescriptionComments(ctx) && typeof type2 !== "string" && Box.isBox(type2) ? getSchemaDescription(type2.schema) : void 0;
+      return {
+        description,
+        line: `${wrapWithQuotesIfNeeded(prop)}${isOptional ? "?" : ""}: ${renderedValue};`
+      };
+    });
+    const shouldRenderMultiline = shouldRenderDescriptionComments(ctx) && renderedProps.some(({ description, line }) => description || line.includes("\n"));
+    if (!shouldRenderMultiline) {
+      const propsString2 = renderedProps.map(({ line }) => line.slice(0, -1)).join(", ");
+      return `{ ${propsString2} }`;
+    }
+    const propsString = renderedProps.map(({ description, line }) => {
+      const comment = description ? `${renderDescriptionComment(description, "  ")}
+` : "";
+      return `${comment}  ${line}`;
+    }).join("\n");
+    return `{
+${propsString}
+}`;
+  }
+  if (Box.isReference(box)) {
+    if (!box.params.generics) {
+      return box.value === "null" ? box.value : prefixRefsWithSchemas ? `Schemas.${box.value}` : box.value;
+    }
+    return `${box.params.name}<${box.params.generics.map((type2) => renderValue(type2)).join(", ")}>`;
+  }
+  return box.value;
+};
 var parameterObjectToString = (parameters, ctx) => {
   if (parameters instanceof Box) {
-    if (ctx.runtime === "none") {
-      return parameters.recompute((box) => {
-        if (Box.isReference(box) && !box.params.generics && box.value !== "null") {
-          box.value = `Schemas.${box.value}`;
-        }
-        return box;
-      }).value;
-    }
-    return parameters.value;
+    return boxToString(parameters, ctx);
   }
   let str = "{";
   for (const [key, box] of Object.entries(parameters)) {
-    str += `${wrapWithQuotesIfNeeded(key)}${box.type === "optional" ? "?" : ""}: ${box.value},
+    str += `${wrapWithQuotesIfNeeded(key)}${box.type === "optional" ? "?" : ""}: ${indentMultiline(boxToString(box, ctx))},
 `;
   }
   return str + "}";
 };
-var responseHeadersObjectToString = (responseHeaders) => {
+var responseHeadersObjectToString = (responseHeaders, ctx) => {
   let str = "{";
   for (const [key, responseHeader] of Object.entries(responseHeaders)) {
-    str += `${wrapWithQuotesIfNeeded(key.toLowerCase())}: ${responseHeader.value},
+    str += `${wrapWithQuotesIfNeeded(key.toLowerCase())}: ${indentMultiline(boxToString(responseHeader, ctx))},
 `;
   }
   return str + "}";
@@ -468,12 +530,7 @@ var responseHeadersObjectToString = (responseHeaders) => {
 var generateResponsesObject = (responses, ctx) => {
   let str = "{";
   for (const [statusCode, responseType] of Object.entries(responses)) {
-    const value = ctx.runtime === "none" ? responseType.recompute((box) => {
-      if (Box.isReference(box) && !box.params.generics && box.value !== "null") {
-        box.value = `Schemas.${box.value}`;
-      }
-      return box;
-    }).value : responseType.value;
+    const value = indentMultiline(boxToString(responseType, ctx));
     str += `${wrapWithQuotesIfNeeded(statusCode)}: ${value},
 `;
   }
@@ -487,7 +544,9 @@ var generateEndpointSchemaList = (ctx) => {
   `;
   ctx.endpointList.map((endpoint) => {
     const parameters = endpoint.parameters ?? {};
-    file += `export type ${endpoint.meta.alias} = {
+    const description = shouldRenderDescriptionComments(ctx) ? endpoint.operation.description : void 0;
+    file += `${description ? `${renderDescriptionComment(description)}
+` : ""}export type ${endpoint.meta.alias} = {
       method: "${endpoint.method.toUpperCase()}",
       path: "${endpoint.path}",
       requestFormat: "${endpoint.requestFormat}",
@@ -495,18 +554,10 @@ var generateEndpointSchemaList = (ctx) => {
             ${parameters.query ? `query:  ${parameterObjectToString(parameters.query, ctx)},` : ""}
         ${parameters.path ? `path:  ${parameterObjectToString(parameters.path, ctx)},` : ""}
         ${parameters.header ? `header:  ${parameterObjectToString(parameters.header, ctx)},` : ""}
-        ${parameters.body ? `body:  ${parameterObjectToString(
-      ctx.runtime === "none" ? parameters.body.recompute((box) => {
-        if (Box.isReference(box) && !box.params.generics) {
-          box.value = `Schemas.${box.value}`;
-        }
-        return box;
-      }) : parameters.body,
-      ctx
-    )},` : ""}
+        ${parameters.body ? `body:  ${parameterObjectToString(parameters.body, ctx)},` : ""}
           }` : "parameters: never,"}
       ${endpoint.responses ? `responses: ${generateResponsesObject(endpoint.responses, ctx)},` : ""}
-      ${endpoint.responseHeaders ? `responseHeaders: ${responseHeadersObjectToString(endpoint.responseHeaders)},` : ""}
+      ${endpoint.responseHeaders ? `responseHeaders: ${responseHeadersObjectToString(endpoint.responseHeaders, ctx)},` : ""}
     }
 `;
   });
@@ -584,7 +635,7 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
 
 export interface Fetcher {
     decodePathParams?: (path: string, pathParams: Record<string, string>) => string
-    encodeSearchParams?: (searchParams: Record<string, unknown> | undefined) => URLSearchParams
+  encodeSearchParams?: (searchParams: Record<string, unknown> | undefined) => URLSearchParams
     //
     fetch: (input: {
       method: Method;
@@ -1026,15 +1077,28 @@ var createRefResolver = (doc, factory2, nameTransform) => {
     const path = split.slice(1, -1).join("/");
     const normalizedPath = path.replace("#/", "").replace("#", "").replaceAll("/", ".");
     const map = get(doc, normalizedPath) ?? {};
+    const existingInfo = byRef.get(correctRef);
+    if (existingInfo) {
+      return map[split[split.length - 1]];
+    }
     const name = split[split.length - 1];
-    let normalized = normalizeString(name);
-    if (nameTransform?.transformSchemaName) {
-      normalized = nameTransform.transformSchemaName(normalized);
+    const kind = normalizedPath.split(".")[1];
+    const baseNormalized = sanitizeName(
+      nameTransform?.transformSchemaName ? nameTransform.transformSchemaName(normalizeString(name)) : normalizeString(name),
+      "schema"
+    );
+    let normalized = baseNormalized;
+    if (refByName.has(normalized) && refByName.get(normalized) !== correctRef) {
+      const kindSuffix = `${baseNormalized}_${kind}`;
+      normalized = kindSuffix;
+      let suffix = 2;
+      while (refByName.has(normalized) && refByName.get(normalized) !== correctRef) {
+        normalized = `${kindSuffix}_${suffix++}`;
+      }
     }
-    normalized = sanitizeName(normalized, "schema");
     nameByRef.set(correctRef, normalized);
     refByName.set(normalized, correctRef);
-    const infos = { ref: correctRef, name, normalized, kind: normalizedPath.split(".")[1] };
+    const infos = { ref: correctRef, name, normalized, kind };
     byRef.set(infos.ref, infos);
     byNormalized.set(infos.normalized, infos);
     const schema = map[name];
@@ -1154,12 +1218,17 @@ var getTransitiveDependencies = (directDependencies) => {
 
 // src/ts-factory.ts
 var tsFactory = createFactory({
-  union: (types) => `(${types.map(unwrap).join(" | ")})`,
-  intersection: (types) => `(${types.map(unwrap).join(" & ")})`,
+  union: (types) => types.length ? `(${types.map(unwrap).join(" | ")})` : "never",
+  intersection: (types) => types.length ? `(${types.map(unwrap).join(" & ")})` : "unknown",
   array: (type2) => `Array<${unwrap(type2)}>`,
   optional: (type2) => `${unwrap(type2)} | undefined`,
   reference: (name, typeArgs) => `${name}${typeArgs ? `<${typeArgs.map(unwrap).join(", ")}>` : ""}`,
-  literal: (value) => value.toString(),
+  literal: (value) => {
+    if (typeof value === "string") return value;
+    if (Box.isBox(value)) return unwrap(value);
+    if (Array.isArray(value) || typeof value === "object") return JSON.stringify(value);
+    return String(value);
+  },
   string: () => "string",
   number: () => "number",
   boolean: () => "boolean",
@@ -1546,7 +1615,7 @@ var generateTanstackQueryFile = async (ctx) => {
         // </ApiClient.request>
   }
 `;
-  return prettify(file);
+  return file;
 };
 
 export {

package/dist/{chunk-62WASHT2.js → chunk-WTE26U5C.js}

@@ -5,10 +5,10 @@ import {
   generateFile,
   generateTanstackQueryFile,
   mapOpenApiEndpoints
-} from "./chunk-ZM3UP6UJ.js";
+} from "./chunk-S3NICEHD.js";
 import {
   prettify
-} from "./chunk-KAEXXJ7X.js";
+} from "./chunk-MAZKDIN3.js";
 
 // src/generate-client-files.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
@@ -100,6 +100,7 @@ async function ensureDir(dirPath) {
 var optionsSchema = type({
   "output?": "string",
   runtime: allowedRuntimes,
+  "format?": "boolean | 'true' | 'false'",
   tanstack: "boolean | string",
   "defaultFetcher?": type({
     "envApiBaseUrl?": "string",
@@ -109,38 +110,47 @@ var optionsSchema = type({
   }),
   schemasOnly: "boolean",
   "includeClient?": "boolean | 'true' | 'false'",
+  "jsdoc?": "boolean | 'true' | 'false'",
   "successStatusCodes?": "string",
   "errorStatusCodes?": "string"
 });
+function parseBooleanOption(value) {
+  if (value === "false") {
+    return false;
+  }
+  if (value === "true") {
+    return true;
+  }
+  return value;
+}
 async function generateClientFiles(input, options) {
   const openApiDoc = await SwaggerParser.bundle(input);
   const ctx = mapOpenApiEndpoints(openApiDoc, options);
   console.log(`Found ${ctx.endpointList.length} endpoints`);
   const successStatusCodes = options.successStatusCodes ? options.successStatusCodes.split(",").map((code) => parseInt(code.trim(), 10)) : void 0;
   const errorStatusCodes = options.errorStatusCodes ? options.errorStatusCodes.split(",").map((code) => parseInt(code.trim(), 10)) : void 0;
-  const includeClient = options.includeClient === "false" ? false : options.includeClient === "true" ? true : options.includeClient;
+  const includeClient = parseBooleanOption(options.includeClient);
+  const jsdoc = parseBooleanOption(options.jsdoc) ?? true;
+  const shouldFormat = parseBooleanOption(options.format) ?? false;
   const generatorOptions = {
     ...ctx,
     runtime: options.runtime,
     schemasOnly: options.schemasOnly,
     nameTransform: options.nameTransform,
     includeClient: includeClient ?? true,
+    jsdoc,
     successStatusCodes: successStatusCodes ?? DEFAULT_SUCCESS_STATUS_CODES,
     errorStatusCodes: errorStatusCodes ?? DEFAULT_ERROR_STATUS_CODES
   };
-  const content = await prettify(generateFile(generatorOptions));
   const outputPath = join(
     cwd,
     options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`
   );
+  const content = await prettify(generateFile(generatorOptions), { enabled: shouldFormat, filePath: outputPath });
   console.log("Generating client...", outputPath);
   await ensureDir(dirname(outputPath));
   await writeFile(outputPath, content);
   if (options.tanstack) {
-    const tanstackContent = await generateTanstackQueryFile({
-      ...generatorOptions,
-      relativeApiClientPath: "./" + basename(outputPath)
-    });
     let tanstackOutputPath;
     if (typeof options.tanstack === "string" && isAbsolute(options.tanstack)) {
       tanstackOutputPath = options.tanstack;
@@ -150,6 +160,13 @@ async function generateClientFiles(input, options) {
         typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`
       );
     }
+    const tanstackContent = await prettify(
+      await generateTanstackQueryFile({
+        ...generatorOptions,
+        relativeApiClientPath: "./" + basename(outputPath)
+      }),
+      { enabled: shouldFormat, filePath: tanstackOutputPath }
+    );
     console.log("Generating tanstack client...", tanstackOutputPath);
     await ensureDir(dirname(tanstackOutputPath));
     await writeFile(tanstackOutputPath, tanstackContent);
@@ -170,9 +187,13 @@ async function generateClientFiles(input, options) {
         typeof options.defaultFetcher === "string" ? options.defaultFetcher : `api.client.ts`
       );
     }
+    const formattedDefaultFetcherContent = await prettify(defaultFetcherContent, {
+      enabled: shouldFormat,
+      filePath: defaultFetcherOutputPath
+    });
     console.log("Generating default fetcher...", defaultFetcherOutputPath);
     await ensureDir(dirname(defaultFetcherOutputPath));
-    await writeFile(defaultFetcherOutputPath, defaultFetcherContent);
+    await writeFile(defaultFetcherOutputPath, formattedDefaultFetcherContent);
   }
   console.log(`Done in ${(/* @__PURE__ */ new Date()).getTime() - now.getTime()}ms !`);
 }

package/dist/cli.js

@@ -1,10 +1,10 @@
 import {
   generateClientFiles
-} from "./chunk-62WASHT2.js";
+} from "./chunk-WTE26U5C.js";
 import {
   allowedRuntimes
-} from "./chunk-ZM3UP6UJ.js";
-import "./chunk-KAEXXJ7X.js";
+} from "./chunk-S3NICEHD.js";
+import "./chunk-MAZKDIN3.js";
 
 // src/cli.ts
 import { cac } from "cac";
@@ -15,7 +15,9 @@ cli.command("<input>", "Generate").option("-o, --output <path>", "Output path fo
   "-r, --runtime <n>",
   `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.toString()}`,
   { default: "none" }
-).option("--schemas-only", "Only generate schemas, skipping client generation (defaults to false)", { default: false }).option("--include-client", "Include API client types and implementation (defaults to true)", { default: true }).option(
+).option("--format", "Format generated files with oxfmt (defaults to false)", { default: false }).option("--schemas-only", "Only generate schemas, skipping client generation (defaults to false)", { default: false }).option("--include-client", "Include API client types and implementation (defaults to true)", { default: true }).option("--jsdoc", "Emit OpenAPI descriptions as JSDoc comments (defaults to false)", {
+  default: true
+}).option(
   "--success-status-codes <codes>",
   "Comma-separated list of success status codes (defaults to 2xx and 3xx ranges)"
 ).option("--error-status-codes <codes>", "Comma-separated list of error status codes (defaults to 4xx and 5xx ranges)").option(

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ReferenceObject } from 'openapi3-ts/oas31';
-import { S as StringOrBox, O as OpenapiSchemaConvertContext, L as LibSchemaObject, B as BoxFactory, m as mapOpenApiEndpoints, N as NameTransformOptions, a as OpenapiSchemaConvertArgs, b as Box, A as AnyBoxDef } from './types-BOJSTQwz.js';
-export { q as AnyBox, j as BoxArray, f as BoxDefinition, i as BoxIntersection, o as BoxKeyword, n as BoxLiteral, p as BoxObject, k as BoxOptional, g as BoxParams, l as BoxRef, h as BoxUnion, c as Endpoint, E as EndpointParameters, F as FactoryCreator, G as GenericFactory, M as Method, R as RefInfo, e as RefResolver, W as WithSchema, d as createRefResolver } from './types-BOJSTQwz.js';
-import * as arktype_internal_methods_string_ts from 'arktype/internal/methods/string.ts';
+import { L as LibSchemaObject, O as OpenapiSchemaConvertContext, B as BoxFactory, S as StringOrBox, m as mapOpenApiEndpoints, N as NameTransformOptions, a as OpenapiSchemaConvertArgs, b as Box, A as AnyBoxDef } from './types-DjwHsNyZ.js';
+export { c as AnyBox, d as BoxArray, e as BoxDefinition, f as BoxIntersection, g as BoxKeyword, h as BoxLiteral, i as BoxObject, j as BoxOptional, k as BoxParams, l as BoxRef, n as BoxUnion, E as Endpoint, o as EndpointParameters, F as FactoryCreator, G as GenericFactory, M as Method, R as RefInfo, p as RefResolver, W as WithSchema, q as createRefResolver } from './types-DjwHsNyZ.js';
+import * as arktype_internal_variants_string_ts from 'arktype/internal/variants/string.ts';
 import * as Codegen from '@sinclair/typebox-codegen';
 import 'openapi3-ts/oas30';
 
@@ -19,8 +19,9 @@ type GeneratorOptions$1 = ReturnType<typeof mapOpenApiEndpoints> & {
     successStatusCodes?: readonly number[];
     errorStatusCodes?: readonly number[];
     includeClient?: boolean;
+    jsdoc?: boolean;
 };
-declare const allowedRuntimes: arktype_internal_methods_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
+declare const allowedRuntimes: arktype_internal_variants_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
 type OutputRuntime = typeof allowedRuntimes.infer;
 declare const runtimeValidationGenerator: {
     arktype: typeof Codegen.ModelToArkType.Generate;

package/dist/index.js

@@ -8,8 +8,7 @@ import {
   openApiSchemaToTs,
   tsFactory,
   unwrap
-} from "./chunk-ZM3UP6UJ.js";
-import "./chunk-KAEXXJ7X.js";
+} from "./chunk-S3NICEHD.js";
 export {
   createBoxFactory,
   createFactory,

package/dist/node.export.d.ts

@@ -1,13 +1,14 @@
-import * as arktype_internal_methods_object_ts from 'arktype/internal/methods/object.ts';
-import { N as NameTransformOptions } from './types-BOJSTQwz.js';
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import { N as NameTransformOptions } from './types-DjwHsNyZ.js';
 import 'openapi3-ts/oas31';
 import 'openapi3-ts/oas30';
 
-declare const optionsSchema: arktype_internal_methods_object_ts.ObjectType<{
+declare const optionsSchema: arktype_internal_variants_object_ts.ObjectType<{
     runtime: "none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod";
     tanstack: string | boolean;
     schemasOnly: boolean;
     output?: string;
+    format?: boolean | "false" | "true";
     defaultFetcher?: {
         envApiBaseUrl?: string;
         clientPath?: string;
@@ -15,6 +16,7 @@ declare const optionsSchema: arktype_internal_methods_object_ts.ObjectType<{
         apiName?: string;
     };
     includeClient?: boolean | "false" | "true";
+    jsdoc?: boolean | "false" | "true";
     successStatusCodes?: string;
     errorStatusCodes?: string;
 }, {}>;
@@ -23,4 +25,4 @@ type GenerateClientFilesOptions = typeof optionsSchema.infer & {
 };
 declare function generateClientFiles(input: string, options: GenerateClientFilesOptions): Promise<void>;
 
-export { generateClientFiles };
+export { type GenerateClientFilesOptions, generateClientFiles };

package/dist/node.export.js

@@ -1,8 +1,8 @@
 import {
   generateClientFiles
-} from "./chunk-62WASHT2.js";
-import "./chunk-ZM3UP6UJ.js";
-import "./chunk-KAEXXJ7X.js";
+} from "./chunk-WTE26U5C.js";
+import "./chunk-S3NICEHD.js";
+import "./chunk-MAZKDIN3.js";
 export {
   generateClientFiles
 };

package/dist/pretty.export.d.ts

@@ -1,5 +1,10 @@
-import { Options } from 'prettier';
+import * as oxfmt from 'oxfmt';
 
-declare const prettify: (str: string, options?: Options | null) => string | Promise<string>;
+type OxcFormatOptions = oxfmt.FormatConfig;
+type PrettifyOptions = OxcFormatOptions & {
+    enabled?: boolean;
+    filePath?: string;
+};
+declare const prettify: (str: string, options?: PrettifyOptions | null) => Promise<string>;
 
 export { prettify };

package/dist/pretty.export.js

@@ -1,6 +1,6 @@
 import {
   prettify
-} from "./chunk-KAEXXJ7X.js";
+} from "./chunk-MAZKDIN3.js";
 export {
   prettify
 };

package/dist/{types-BOJSTQwz.d.ts → types-DjwHsNyZ.d.ts}

@@ -43,7 +43,7 @@ type RefInfo = {
     kind: "schemas" | "responses" | "parameters" | "requestBodies" | "headers";
 };
 declare const createRefResolver: (doc: OpenAPIObject, factory: GenericFactory, nameTransform?: NameTransformOptions) => {
-    get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
+    get: <T = LibSchemaObject>(ref: string) => T;
     unwrap: <T extends ReferenceObject | {}>(component: T) => Exclude<T, ReferenceObject>;
     getInfosByRef: (ref: string) => RefInfo;
     infos: Map<string, RefInfo>;
@@ -63,7 +63,7 @@ declare const mapOpenApiEndpoints: (doc: OpenAPIObject, options?: {
 }) => {
     doc: OpenAPIObject;
     refs: {
-        get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
+        get: <T = LibSchemaObject>(ref: string) => T;
         unwrap: <T extends openapi3_ts_oas31.ReferenceObject | {}>(component: T) => Exclude<T, openapi3_ts_oas31.ReferenceObject>;
         getInfosByRef: (ref: string) => RefInfo;
         infos: Map<string, RefInfo>;
@@ -239,4 +239,4 @@ type GenericFactory = {
     never: () => string;
 };
 
-export { type AnyBoxDef as A, type BoxFactory as B, type EndpointParameters as E, type FactoryCreator as F, type GenericFactory as G, type LibSchemaObject as L, type Method as M, type NameTransformOptions as N, type OpenapiSchemaConvertContext as O, type RefInfo as R, type StringOrBox as S, type WithSchema as W, type OpenapiSchemaConvertArgs as a, Box as b, type Endpoint as c, createRefResolver as d, type RefResolver as e, type BoxDefinition as f, type BoxParams as g, type BoxUnion as h, type BoxIntersection as i, type BoxArray as j, type BoxOptional as k, type BoxRef as l, mapOpenApiEndpoints as m, type BoxLiteral as n, type BoxKeyword as o, type BoxObject as p, type AnyBox as q };
+export { type AnyBoxDef as A, type BoxFactory as B, type Endpoint as E, type FactoryCreator as F, type GenericFactory as G, type LibSchemaObject as L, type Method as M, type NameTransformOptions as N, type OpenapiSchemaConvertContext as O, type RefInfo as R, type StringOrBox as S, type WithSchema as W, type OpenapiSchemaConvertArgs as a, Box as b, type AnyBox as c, type BoxArray as d, type BoxDefinition as e, type BoxIntersection as f, type BoxKeyword as g, type BoxLiteral as h, type BoxObject as i, type BoxOptional as j, type BoxParams as k, type BoxRef as l, mapOpenApiEndpoints as m, type BoxUnion as n, type EndpointParameters as o, type RefResolver as p, createRefResolver as q };