@trpc/openapi 11.18.1-canary.9 → 11.19.0-alpha

package/dist/{cli.js → cli.mjs}

@@ -1,12 +1,9 @@
 #!/usr/bin/env node
-import * as fs$1 from "node:fs";
 import * as fs from "node:fs";
-import * as path$1 from "node:path";
 import * as path from "node:path";
 import { parseArgs } from "node:util";
 import * as ts from "typescript";
 import { pathToFileURL } from "node:url";
-
 //#region src/schemaExtraction.ts
 /**
 * Zod v4 stores `.describe()` strings in `globalThis.__zod_globalRegistry`,
@@ -36,7 +33,7 @@ function zodArrayElement(schema) {
 	return null;
 }
 /** Wrapper def types whose inner schema is accessible via `innerType` or `in`. */
-const wrapperDefTypes = new Set([
+const wrapperDefTypes = /* @__PURE__ */ new Set([
 	"optional",
 	"nullable",
 	"nonoptional",
@@ -120,13 +117,13 @@ function walkZodShape(schema, prefix, ctx) {
 	const shape = zodObjectShape(unwrapped);
 	if (!shape) return;
 	for (const [key, fieldSchema] of Object.entries(shape)) {
-		const path$2 = prefix ? `${prefix}.${key}` : key;
+		const path = prefix ? `${prefix}.${key}` : key;
 		const meta = ctx.registry.get(fieldSchema);
 		const unwrappedField = unwrapZodSchema(fieldSchema);
 		const innerMeta = unwrappedField !== fieldSchema ? ctx.registry.get(unwrappedField) : void 0;
 		const description = meta?.description ?? innerMeta?.description;
-		if (description) ctx.map.properties.set(path$2, description);
-		walkZodShape(unwrappedField, path$2, ctx);
+		if (description) ctx.map.properties.set(path, description);
+		walkZodShape(unwrappedField, path, ctx);
 	}
 }
 /** Check whether a value looks like a tRPC router instance at runtime. */
@@ -158,8 +155,7 @@ function findRouterExport(mod, exportName) {
 */
 async function tryImportRouter(resolvedPath, exportName) {
 	try {
-		const mod = await import(pathToFileURL(resolvedPath).href);
-		return findRouterExport(mod, exportName);
+		return findRouterExport(await import(pathToFileURL(resolvedPath).href), exportName);
 	} catch {
 		return null;
 	}
@@ -241,15 +237,12 @@ function setNestedDescription({ schema, pathParts, description, schemas }) {
 		const items = getArrayItemsSchema(schema);
 		if (!items) return;
 		if (rest.length === 0) setLeafDescription(items, description);
-		else {
-			const target = resolveSchemaRef(items, schemas) ?? items;
-			setNestedDescription({
-				schema: target,
-				pathParts: rest,
-				description,
-				schemas
-			});
-		}
+		else setNestedDescription({
+			schema: resolveSchemaRef(items, schemas) ?? items,
+			pathParts: rest,
+			description,
+			schemas
+		});
 		return;
 	}
 	const propSchema = getPropertySchema(schema, head);
@@ -257,16 +250,14 @@ function setNestedDescription({ schema, pathParts, description, schemas }) {
 	if (rest.length === 0) setLeafDescription(propSchema, description);
 	else {
 		const target = getArrayItemsSchema(propSchema) ?? propSchema;
-		const resolvedTarget = resolveSchemaRef(target, schemas) ?? target;
 		setNestedDescription({
-			schema: resolvedTarget,
+			schema: resolveSchemaRef(target, schemas) ?? target,
 			pathParts: rest,
 			description,
 			schemas
 		});
 	}
 }
-
 //#endregion
 //#region src/generate.ts
 const PRIMITIVE_FLAGS = ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.Boolean | ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BooleanLiteral;
@@ -279,6 +270,29 @@ function isPrimitive(type) {
 function isObjectType(type) {
 	return hasFlag(type, ts.TypeFlags.Object);
 }
+const STANDARD_FUNCTION_INTERFACES = /* @__PURE__ */ new Set([
+	"Function",
+	"CallableFunction",
+	"NewableFunction"
+]);
+function isStandardFunctionInterface(type) {
+	const symbol = type.getSymbol();
+	const name = symbol?.getName();
+	if (!name || !STANDARD_FUNCTION_INTERFACES.has(name)) return false;
+	return symbol?.declarations?.some((d) => /(^|[\\/])lib\.[^\\/]*\.d\.ts$/.test(d.getSourceFile().fileName)) ?? false;
+}
+function isFunctionType(type) {
+	return type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0 || isStandardFunctionInterface(type);
+}
+function hasFunctionMember(type) {
+	if (isFunctionType(type)) return true;
+	return type.isUnion() && type.types.some(isFunctionType);
+}
+function isUnserialisableType(type) {
+	if (isFunctionType(type)) return true;
+	if (!type.isUnion() || !type.types.some(isFunctionType)) return false;
+	return !type.types.some((m) => !isFunctionType(m) && !hasFlag(m, ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Null));
+}
 function isOptionalSymbol(sym) {
 	return (sym.flags & ts.SymbolFlags.Optional) !== 0;
 }
@@ -294,7 +308,7 @@ function unwrapBrand(type) {
 	if (first && hasObject) return first;
 	return type;
 }
-const ANONYMOUS_NAMES = new Set([
+const ANONYMOUS_NAMES = /* @__PURE__ */ new Set([
 	"__type",
 	"__object",
 	"Object",
@@ -353,8 +367,8 @@ function typeToJsonSchema(type, ctx, depth = 0) {
 		const storedSchema = ctx.schemas[existingRef];
 		if (storedSchema && (isNonEmptySchema(storedSchema) || ctx.visited.has(type))) return schemaRef(existingRef);
 		ctx.schemas[existingRef] = storedSchema ?? {};
-		const schema$1 = convertTypeToSchema(type, ctx, depth);
-		if (!isSelfSchemaRef(schema$1, existingRef)) ctx.schemas[existingRef] = schema$1;
+		const schema = convertTypeToSchema(type, ctx, depth);
+		if (!isSelfSchemaRef(schema, existingRef)) ctx.schemas[existingRef] = schema;
 		return schemaRef(existingRef);
 	}
 	const schema = convertTypeToSchema(type, ctx, depth);
@@ -377,8 +391,7 @@ function typeToJsonSchema(type, ctx, depth = 0) {
 function handleCyclicRef(type, ctx) {
 	let refName = ctx.typeToRef.get(type);
 	if (!refName) {
-		const name = getTypeName(type) ?? "RecursiveType";
-		refName = ensureUniqueName(name, ctx.schemas);
+		refName = ensureUniqueName(getTypeName(type) ?? "RecursiveType", ctx.schemas);
 		ctx.typeToRef.set(type, refName);
 		ctx.schemas[refName] = {};
 	}
@@ -405,18 +418,14 @@ function convertPrimitiveOrLiteral(type, flags, checker) {
 		type: "number",
 		const: type.value
 	};
-	if (flags & ts.TypeFlags.BooleanLiteral) {
-		const isTrue = checker.typeToString(type) === "true";
-		return {
-			type: "boolean",
-			const: isTrue
-		};
-	}
+	if (flags & ts.TypeFlags.BooleanLiteral) return {
+		type: "boolean",
+		const: checker.typeToString(type) === "true"
+	};
 	return null;
 }
 function convertUnionType(type, ctx, depth) {
-	const members = type.types;
-	const defined = members.filter((m) => !hasFlag(m, ts.TypeFlags.Undefined | ts.TypeFlags.Void));
+	const defined = type.types.filter((m) => !hasFlag(m, ts.TypeFlags.Undefined | ts.TypeFlags.Void) && !isFunctionType(m));
 	if (defined.length === 0) return {};
 	const hasNull = defined.some((m) => hasFlag(m, ts.TypeFlags.Null));
 	const nonNull = defined.filter((m) => !hasFlag(m, ts.TypeFlags.Null));
@@ -450,13 +459,9 @@ function detectDiscriminatorProperty(schemas) {
 	const first = schemas[0];
 	if (!first?.properties) return null;
 	const firstProps = Object.keys(first.properties);
-	for (const prop of firstProps) {
-		const allHaveConst = schemas.every((s) => {
-			const propSchema = s.properties?.[prop];
-			return propSchema !== void 0 && propSchema.const !== void 0 && s.required?.includes(prop);
-		});
-		if (allHaveConst) return prop;
-	}
+	for (const prop of firstProps) if (schemas.every((s) => {
+		return (s.properties?.[prop])?.const !== void 0 && s.required?.includes(prop);
+	})) return prop;
 	return null;
 }
 /** A schema that is just `{ type: "somePrimitive" }` with no other keys. */
@@ -470,14 +475,12 @@ function isSimpleTypeSchema(s) {
 */
 function tryCollapseLiteralUnion(nonNull, hasNull) {
 	if (nonNull.length <= 1) return null;
-	const allLiterals = nonNull.every((m) => hasFlag(m, ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral));
-	if (!allLiterals) return null;
+	if (!nonNull.every((m) => hasFlag(m, ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral))) return null;
 	const [first] = nonNull;
 	if (!first) return null;
 	const isString = hasFlag(first, ts.TypeFlags.StringLiteral);
 	const targetFlag = isString ? ts.TypeFlags.StringLiteral : ts.TypeFlags.NumberLiteral;
-	const allSameKind = nonNull.every((m) => hasFlag(m, targetFlag));
-	if (!allSameKind) return null;
+	if (!nonNull.every((m) => hasFlag(m, targetFlag))) return null;
 	const values = nonNull.map((m) => isString ? m.value : m.value);
 	const baseType = isString ? "string" : "number";
 	return {
@@ -486,9 +489,7 @@ function tryCollapseLiteralUnion(nonNull, hasNull) {
 	};
 }
 function convertIntersectionType(type, ctx, depth) {
-	const hasPrimitiveMember = type.types.some(isPrimitive);
-	const nonBrand = hasPrimitiveMember ? type.types.filter((m) => !isObjectType(m)) : type.types;
-	const schemas = nonBrand.map((m) => typeToJsonSchema(m, ctx, depth + 1)).filter(isNonEmptySchema);
+	const schemas = (type.types.some(isPrimitive) ? type.types.filter((m) => !isObjectType(m)) : type.types).map((m) => typeToJsonSchema(m, ctx, depth + 1)).filter(isNonEmptySchema);
 	if (schemas.length === 0) return {};
 	const [onlySchema] = schemas;
 	if (schemas.length === 1 && onlySchema !== void 0) return onlySchema;
@@ -547,10 +548,9 @@ function convertArrayType(type, ctx, depth) {
 }
 function convertTupleType(type, ctx, depth) {
 	const args = ctx.checker.getTypeArguments(type);
-	const schemas = args.map((a) => typeToJsonSchema(a, ctx, depth + 1));
 	return {
 		type: "array",
-		prefixItems: schemas,
+		prefixItems: args.map((a) => typeToJsonSchema(a, ctx, depth + 1)),
 		items: false,
 		minItems: args.length,
 		maxItems: args.length
@@ -566,8 +566,7 @@ function convertPlainObject(type, ctx, depth) {
 	};
 	let autoRegName = null;
 	const tsName = getTypeName(type);
-	const isNamedUnregisteredType = tsName !== null && typeProps.length > 0 && !ctx.typeToRef.has(type);
-	if (isNamedUnregisteredType) {
+	if (tsName !== null && typeProps.length > 0 && !ctx.typeToRef.has(type)) {
 		autoRegName = ensureUniqueName(tsName, ctx.schemas);
 		ctx.typeToRef.set(type, autoRegName);
 		ctx.schemas[autoRegName] = {};
@@ -578,18 +577,19 @@ function convertPlainObject(type, ctx, depth) {
 	for (const prop of typeProps) {
 		if (shouldSkipPropertySymbol(prop)) continue;
 		const propType = checker.getTypeOfSymbol(prop);
+		if (isUnserialisableType(propType)) continue;
 		const propSchema = typeToJsonSchema(propType, ctx, depth + 1);
 		const jsDoc = getJsDocComment(prop, checker);
 		if (jsDoc && !propSchema.description && !propSchema.$ref) propSchema.description = jsDoc;
 		properties[prop.name] = propSchema;
-		if (!isOptionalSymbol(prop)) required.push(prop.name);
+		if (!isOptionalSymbol(prop) && !hasFunctionMember(propType)) required.push(prop.name);
 	}
 	ctx.visited.delete(type);
 	const result = { type: "object" };
 	if (Object.keys(properties).length > 0) result.properties = properties;
 	if (required.length > 0) result.required = required;
 	if (stringIndexType) result.additionalProperties = typeToJsonSchema(stringIndexType, ctx, depth + 1);
-	else if (Object.keys(properties).length > 0) result.additionalProperties = false;
+	else if (typeProps.length > 0) result.additionalProperties = false;
 	const registeredName = autoRegName ?? ctx.typeToRef.get(type);
 	if (registeredName) {
 		ctx.schemas[registeredName] = result;
@@ -607,8 +607,7 @@ function convertObjectType(type, ctx, depth) {
 /** Core type-to-schema conversion (no ref handling). */
 function convertTypeToSchema(type, ctx, depth) {
 	if (ctx.visited.has(type)) return handleCyclicRef(type, ctx);
-	const flags = type.getFlags();
-	const primitive = convertPrimitiveOrLiteral(type, flags, ctx.checker);
+	const primitive = convertPrimitiveOrLiteral(type, type.getFlags(), ctx.checker);
 	if (primitive) return primitive;
 	if (type.isUnion()) {
 		ctx.visited.add(type);
@@ -622,6 +621,7 @@ function convertTypeToSchema(type, ctx, depth) {
 		ctx.visited.delete(type);
 		return result;
 	}
+	if (isFunctionType(type)) return {};
 	if (isObjectType(type)) return convertObjectType(type, ctx, depth);
 	return {};
 }
@@ -639,23 +639,20 @@ function getProcedureTypeName(defType, checker) {
 }
 function isVoidLikeInput(inputType) {
 	if (!inputType) return true;
-	const isVoidOrUndefinedOrNever = hasFlag(inputType, ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never);
-	if (isVoidOrUndefinedOrNever) return true;
-	const isUnionOfVoids = inputType.isUnion() && inputType.types.every((t) => hasFlag(t, ts.TypeFlags.Void | ts.TypeFlags.Undefined));
-	return isUnionOfVoids;
+	if (hasFlag(inputType, ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never)) return true;
+	return inputType.isUnion() && inputType.types.every((t) => hasFlag(t, ts.TypeFlags.Void | ts.TypeFlags.Undefined));
 }
 function shouldIncludeProcedureInOpenAPI(type) {
 	return type !== "subscription";
 }
-function getProcedureInputTypeName(type, path$2) {
+function getProcedureInputTypeName(type, path) {
 	const directName = getTypeName(type);
 	if (directName) return directName;
 	for (const sym of [type.aliasSymbol, type.getSymbol()].filter((candidate) => !!candidate)) for (const declaration of sym.declarations ?? []) {
 		const declarationName = ts.getNameOfDeclaration(declaration)?.getText();
 		if (declarationName && !ANONYMOUS_NAMES.has(declarationName) && !declarationName.startsWith("__")) return declarationName;
 	}
-	const fallbackName = path$2.split(".").filter(Boolean).map((segment) => segment.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")).join("");
-	return `${fallbackName || "Procedure"}Input`;
+	return `${path.split(".").filter(Boolean).map((segment) => segment.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")).join("") || "Procedure"}Input`;
 }
 function isUnknownLikeType(type) {
 	return hasFlag(type, ts.TypeFlags.Unknown | ts.TypeFlags.Any);
@@ -685,14 +682,11 @@ function recoverProcedureInputType(def, checker) {
 		if (callee.name.text !== "input") return;
 		const [parserExpr] = expr.arguments;
 		if (!parserExpr) return;
-		const parserType = checker.getTypeAtLocation(parserExpr);
-		const standardSym = parserType.getProperty("~standard");
+		const standardSym = checker.getTypeAtLocation(parserExpr).getProperty("~standard");
 		if (!standardSym) return;
-		const standardType = checker.getTypeOfSymbolAtLocation(standardSym, parserExpr);
-		const typesSym = standardType.getProperty("types");
+		const typesSym = checker.getTypeOfSymbolAtLocation(standardSym, parserExpr).getProperty("types");
 		if (!typesSym) return;
-		const typesType = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(typesSym, parserExpr));
-		const outputSym = typesType.getProperty("output");
+		const outputSym = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(typesSym, parserExpr)).getProperty("output");
 		if (!outputSym) return;
 		const outputType = checker.getTypeOfSymbolAtLocation(outputSym, parserExpr);
 		if (!isUnknownLikeType(outputType)) recovered = outputType;
@@ -746,22 +740,18 @@ function extractProcedure(def, ctx) {
 function getJsDocComment(sym, checker) {
 	const normalize = (filePath) => filePath.replace(/\\/g, "/");
 	const declarations = sym.declarations ?? [];
-	const isExternalNodeModulesDeclaration = declarations.length > 0 && declarations.every((declaration) => {
+	if (declarations.length > 0 && declarations.every((declaration) => {
 		const sourceFile = declaration.getSourceFile();
 		if (!sourceFile.isDeclarationFile) return false;
-		const declarationPath = normalize(sourceFile.fileName);
-		if (!declarationPath.includes("/node_modules/")) return false;
+		if (!normalize(sourceFile.fileName).includes("/node_modules/")) return false;
 		try {
-			const realPath = normalize(fs$1.realpathSync.native(sourceFile.fileName));
-			if (!realPath.includes("/node_modules/")) return false;
+			if (!normalize(fs.realpathSync.native(sourceFile.fileName)).includes("/node_modules/")) return false;
 		} catch {}
 		return true;
-	});
-	if (isExternalNodeModulesDeclaration) return void 0;
+	})) return;
 	const parts = sym.getDocumentationComment(checker);
-	if (parts.length === 0) return void 0;
-	const text = parts.map((p) => p.text).join("");
-	return text || void 0;
+	if (parts.length === 0) return;
+	return parts.map((p) => p.text).join("") || void 0;
 }
 function walkType(opts) {
 	const { type, ctx, currentPath, description, symbol } = opts;
@@ -791,28 +781,21 @@ function walkType(opts) {
 	}
 	const routerSym = defType.getProperty("router");
 	if (!routerSym) return;
-	const isRouter = checker.typeToString(checker.getTypeOfSymbol(routerSym)) === "true";
-	if (!isRouter) return;
+	if (!(checker.typeToString(checker.getTypeOfSymbol(routerSym)) === "true")) return;
 	const recordSym = defType.getProperty("record");
 	if (!recordSym) return;
 	ctx.seen.add(type);
-	const recordType = checker.getTypeOfSymbol(recordSym);
-	walkRecord(recordType, ctx, currentPath);
+	walkRecord(checker.getTypeOfSymbol(recordSym), ctx, currentPath);
 	ctx.seen.delete(type);
 }
 function walkRecord(recordType, ctx, prefix) {
-	for (const prop of recordType.getProperties()) {
-		const propType = ctx.schemaCtx.checker.getTypeOfSymbol(prop);
-		const fullPath = prefix ? `${prefix}.${prop.name}` : prop.name;
-		const description = getJsDocComment(prop, ctx.schemaCtx.checker);
-		walkType({
-			type: propType,
-			ctx,
-			currentPath: fullPath,
-			description,
-			symbol: prop
-		});
-	}
+	for (const prop of recordType.getProperties()) walkType({
+		type: ctx.schemaCtx.checker.getTypeOfSymbol(prop),
+		ctx,
+		currentPath: prefix ? `${prefix}.${prop.name}` : prop.name,
+		description: getJsDocComment(prop, ctx.schemaCtx.checker),
+		symbol: prop
+	});
 }
 function loadCompilerOptions(startDir) {
 	const configPath = ts.findConfigFile(startDir, (f) => ts.sys.fileExists(f), "tsconfig.json");
@@ -823,9 +806,8 @@ function loadCompilerOptions(startDir) {
 		noEmit: true
 	};
 	const configFile = ts.readConfigFile(configPath, (f) => ts.sys.readFile(f));
-	const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path$1.dirname(configPath));
 	const options = {
-		...parsed.options,
+		...ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath)).options,
 		noEmit: true
 	};
 	if (options.moduleResolution === void 0) {
@@ -880,14 +862,13 @@ const DEFAULT_ERROR_SCHEMA = {
 */
 function wrapInSuccessEnvelope(outputSchema) {
 	const hasOutput = outputSchema !== null && isNonEmptySchema(outputSchema);
-	const resultSchema = {
-		type: "object",
-		properties: { ...hasOutput ? { data: outputSchema } : {} },
-		...hasOutput ? { required: ["data"] } : {}
-	};
 	return {
 		type: "object",
-		properties: { result: resultSchema },
+		properties: { result: {
+			type: "object",
+			properties: { ...hasOutput ? { data: outputSchema } : {} },
+			...hasOutput ? { required: ["data"] } : {}
+		} },
 		required: ["result"]
 	};
 }
@@ -961,9 +942,9 @@ function buildOpenAPIDocument(procedures, options, meta = { errorSchema: null })
 * @param options - Optional generation settings (export name, title, version).
 */
 async function generateOpenAPIDocument(routerFilePath, options = {}) {
-	const resolvedPath = path$1.resolve(routerFilePath);
+	const resolvedPath = path.resolve(routerFilePath);
 	const exportName = options.exportName ?? "AppRouter";
-	const compilerOptions = loadCompilerOptions(path$1.dirname(resolvedPath));
+	const compilerOptions = loadCompilerOptions(path.dirname(resolvedPath));
 	const program = ts.createProgram([resolvedPath], compilerOptions);
 	const checker = program.getTypeChecker();
 	const sourceFile = program.getSourceFile(resolvedPath);
@@ -1005,9 +986,23 @@ async function generateOpenAPIDocument(routerFilePath, options = {}) {
 		schemas: schemaCtx.schemas
 	});
 }
-
 //#endregion
 //#region src/cli.ts
+/**
+* trpc-openapi – CLI that generates an OpenAPI 3.1 document from a tRPC
+* AppRouter type.
+*
+* Usage:
+*   trpc-openapi <router-file> [options]
+*
+* Options:
+*   --export, -e   Name of the exported router symbol  (default: AppRouter)
+*   --output, -o   Output file path                    (default: openapi.json)
+*   --title        OpenAPI info.title                  (default: tRPC API)
+*   --version      OpenAPI info.version                (default: 0.0.0)
+*   --server-url   OpenAPI servers[].url (include any tRPC prefix)
+*   --help, -h     Show this help message
+*/
 function parseArgs$1(argv) {
 	let parsed;
 	try {
@@ -1116,5 +1111,5 @@ async function main() {
 	console.log(`OpenAPI document written to: ${outputPath}`);
 }
 main();
-
-//#endregion
+//#endregion
+export {};

package/dist/heyapi/index.cjs

@@ -1,39 +1,28 @@
-const require_objectSpread2$1 = require('../objectSpread2-Cw30I7tb.cjs');
-
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutPropertiesLoose.js
-var require_objectWithoutPropertiesLoose = require_objectSpread2$1.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutPropertiesLoose.js"(exports, module) {
-	function _objectWithoutPropertiesLoose(r, e) {
-		if (null == r) return {};
-		var t = {};
-		for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-			if (e.includes(n)) continue;
-			t[n] = r[n];
-		}
-		return t;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objectSpread2 = require("../objectSpread2-C2ceYbQe.cjs");
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
 	}
-	module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-
+	return t;
+}
 //#endregion
-//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutProperties.js
-var require_objectWithoutProperties = require_objectSpread2$1.__commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutProperties.js"(exports, module) {
-	var objectWithoutPropertiesLoose = require_objectWithoutPropertiesLoose();
-	function _objectWithoutProperties$1(e, t) {
-		if (null == e) return {};
-		var o, r, i = objectWithoutPropertiesLoose(e, t);
-		if (Object.getOwnPropertySymbols) {
-			var s = Object.getOwnPropertySymbols(e);
-			for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
-		}
-		return i;
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
 	}
-	module.exports = _objectWithoutProperties$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-
+	return i;
+}
 //#endregion
 //#region src/heyapi/index.ts
-var import_objectSpread2 = require_objectSpread2$1.__toESM(require_objectSpread2$1.require_objectSpread2(), 1);
-var import_objectWithoutProperties = require_objectSpread2$1.__toESM(require_objectWithoutProperties(), 1);
 const _excluded = ["transformer"];
 function resolveTransformer(transformer) {
 	if ("input" in transformer) return transformer;
@@ -64,11 +53,9 @@ function createTRPCHeyApiTypeResolvers() {
 	return {
 		string(ctx) {
 			if (ctx.schema.format === "date-time" || ctx.schema.format === "date") return ctx.$.type("Date");
-			return void 0;
 		},
 		number(ctx) {
 			if (ctx.schema.format === "bigint") return ctx.$.type("bigint");
-			return void 0;
 		}
 	};
 }
@@ -77,7 +64,7 @@ function createTRPCHeyApiTypeResolvers() {
 */
 function createTRPCHeyApiClientConfig(opts) {
 	const transformer = (opts === null || opts === void 0 ? void 0 : opts.transformer) ? resolveTransformer(opts.transformer) : void 0;
-	return (0, import_objectSpread2.default)({ querySerializer: (query) => {
+	return require_objectSpread2._objectSpread2({ querySerializer: (query) => {
 		const params = new URLSearchParams();
 		for (const [key, value] of Object.entries(query)) {
 			if (value === void 0) continue;
@@ -128,14 +115,13 @@ function createTRPCErrorInterceptor(transformerOpts) {
 * ```
 */
 function configureTRPCHeyApiClient(client, opts) {
-	const { transformer } = opts, heyConfig = (0, import_objectWithoutProperties.default)(opts, _excluded);
+	const { transformer } = opts, heyConfig = _objectWithoutProperties(opts, _excluded);
 	const trpcConfig = createTRPCHeyApiClientConfig({ transformer });
-	client.setConfig((0, import_objectSpread2.default)((0, import_objectSpread2.default)({}, heyConfig), trpcConfig));
+	client.setConfig(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, heyConfig), trpcConfig));
 	if (transformer) client.interceptors.error.use(createTRPCErrorInterceptor(transformer));
 }
-
 //#endregion
 exports.configureTRPCHeyApiClient = configureTRPCHeyApiClient;
 exports.createTRPCErrorInterceptor = createTRPCErrorInterceptor;
 exports.createTRPCHeyApiClientConfig = createTRPCHeyApiClientConfig;
-exports.createTRPCHeyApiTypeResolvers = createTRPCHeyApiTypeResolvers;
+exports.createTRPCHeyApiTypeResolvers = createTRPCHeyApiTypeResolvers;

package/dist/heyapi/index.d.cts

@@ -1,14 +1,13 @@
 import { Plugins } from "@hey-api/openapi-ts";
 import { TRPCCombinedDataTransformer, TRPCDataTransformer } from "@trpc/server";
-
 //#region src/heyapi/index.d.ts
-type DataTransformerOptions = TRPCDataTransformer | TRPCCombinedDataTransformer;
-interface TRPCHeyApiClientOptions {
+export type DataTransformerOptions = TRPCDataTransformer | TRPCCombinedDataTransformer;
+export interface TRPCHeyApiClientOptions {
   transformer?: DataTransformerOptions;
 }
-type HeyAPIResolvers = Plugins.HeyApiTypeScript.Resolvers;
-type HeyApiConfig = ReturnType<Plugins.HeyApiClientFetch.Client['getConfig']>;
-type TRPCHeyApiClientConfig = Required<Pick<HeyApiConfig, 'querySerializer'>> & Pick<HeyApiConfig, 'bodySerializer' | 'responseTransformer'>;
+export type HeyAPIResolvers = Plugins.HeyApiTypeScript.Resolvers;
+export type HeyApiConfig = ReturnType<Plugins.HeyApiClientFetch.Client['getConfig']>;
+export type TRPCHeyApiClientConfig = Required<Pick<HeyApiConfig, 'querySerializer'>> & Pick<HeyApiConfig, 'bodySerializer' | 'responseTransformer'>;
 /**
  * Returns the `~resolvers` object for the `@hey-api/typescript` plugin.
  *
@@ -27,11 +26,11 @@ type TRPCHeyApiClientConfig = Required<Pick<HeyApiConfig, 'querySerializer'>> &
  * });
  * ```
  */
-declare function createTRPCHeyApiTypeResolvers(): HeyAPIResolvers;
+export declare function createTRPCHeyApiTypeResolvers(): HeyAPIResolvers;
 /**
  * @internal - Prefer `configureTRPCHeyApiClient`
  */
-declare function createTRPCHeyApiClientConfig(opts?: TRPCHeyApiClientOptions): {
+export declare function createTRPCHeyApiClientConfig(opts?: TRPCHeyApiClientOptions): {
   readonly bodySerializer?: ((body: unknown) => string) | undefined;
   readonly responseTransformer?: ((data: unknown) => Promise<unknown>) | undefined;
   readonly querySerializer: (query: Record<string, unknown>) => string;
@@ -39,7 +38,7 @@ declare function createTRPCHeyApiClientConfig(opts?: TRPCHeyApiClientOptions): {
 /**
  * @internal - Prefer `configureTRPCHeyApiClient`
  */
-declare function createTRPCErrorInterceptor(transformerOpts: DataTransformerOptions): (error: unknown) => unknown;
+export declare function createTRPCErrorInterceptor(transformerOpts: DataTransformerOptions): (error: unknown) => unknown;
 /**
  * Configures a hey-api client for use with a tRPC OpenAPI backend.
  *
@@ -59,8 +58,6 @@ declare function createTRPCErrorInterceptor(transformerOpts: DataTransformerOpti
  * });
  * ```
  */
-declare function configureTRPCHeyApiClient(client: Plugins.HeyApiClientFetch.Client, opts: TRPCHeyApiClientOptions & Omit<HeyApiConfig, keyof TRPCHeyApiClientConfig>): void;
-//# sourceMappingURL=index.d.ts.map
+export declare function configureTRPCHeyApiClient(client: Plugins.HeyApiClientFetch.Client, opts: TRPCHeyApiClientOptions & Omit<HeyApiConfig, keyof TRPCHeyApiClientConfig>): void;
 //#endregion
-export { DataTransformerOptions, HeyAPIResolvers, HeyApiConfig, TRPCHeyApiClientConfig, TRPCHeyApiClientOptions, configureTRPCHeyApiClient, createTRPCErrorInterceptor, createTRPCHeyApiClientConfig, createTRPCHeyApiTypeResolvers };
 //# sourceMappingURL=index.d.cts.map

package/dist/heyapi/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/heyapi/index.ts"],"sourcesContent":[],"mappings":";;;;KAMY,sBAAA,GACR,sBACA;UACa,uBAAA;EAHL,WAAA,CAAA,EAII,sBAJkB;;AAC9B,KAMQ,eAAA,GAAkB,OAAA,CAAQ,gBAAA,CAAiB,SANnD;AACA,KAOQ,YAAA,GAAe,UAPvB,CAQF,OAAA,CAAQ,iBAAA,CAAkB,MARxB,CAAA,WAAA,CAAA,CAAA;AAA2B,KAWnB,sBAAA,GAAyB,QAXN,CAY7B,IAZ6B,CAYxB,YAZwB,EAAA,iBAAA,CAAA,CAAA,GAc7B,IAd6B,CAcxB,YAdwB,EAAA,gBAAA,GAAA,qBAAA,CAAA;AAC/B;AAIA;AAEA;;;;AAAqC;AAIrC;;;;;;;AAGM;AA6BN;AAoBA;;AAAoD,iBApBpC,6BAAA,CAAA,CAoBoC,EApBH,eAoBG;;;AAMjB;AA2CnB,iBAjDA,4BAAA,CAkDG,IAAsB,CAAtB,EAlDiC,uBAkDX,CAAA,EAAA;EAgCzB,SAAA,cAAA,CAAA,EAAA,CAAA,CAAyB,IAAA,EAAA,OAAA,EAAA,GAAA,MAAA,CAAA,GAAA,SAAA;EAAA,SAAA,mBAAA,CAAA,EAAA,CAAA,CAAA,IAAA,EAAA,OAAA,EAAA,GAlDM,OAkDN,CAAA,OAAA,CAAA,CAAA,GAAA,SAAA;EAAA,SAC/B,eAAQ,EAAA,CAAA,KAAkB,EA7EP,MA6EO,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,MAAA;CAAM;;;;AAElC,iBApCQ,0BAAA,CAoCR,eAAA,EAnCW,sBAmCX,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,OAAA;;;;;;;;;;;;;;;;;;;;iBAHQ,yBAAA,SACN,OAAA,CAAQ,iBAAA,CAAkB,cAC5B,0BACJ,KAAK,oBAAoB"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/heyapi/index.ts"],"mappings":";;;YAMY,yBACV,sBAAsB;iBACP;EACf,cAAc;;YAGJ,kBAAkB,QAAQ,iBAAiB;YAE3C,eAAe,WACzB,QAAQ,kBAAkB;YAGhB,yBAAyB,SACnC,KAAK,oCAEL,KAAK;;;;;;;;;;;;;;;;;;;wBA6BS,iCAAiC;;;;wBAoBjC,6BAA6B,OAAO;WA4BvB,mBAAA;WAIW,wBAAA,kBAAO;WA1BlB,kBAAA,OAAA;;;;;wBA2Cb,2BACd,iBAAiB,0BAGT;;;;;;;;;;;;;;;;;;;;wBA6BM,0BACd,QAAQ,QAAQ,kBAAkB,QAClC,MAAM,0BACJ,KAAK,oBAAoB"}