@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.61

package/dist/response-hnSw2NKE.cjs

@@ -0,0 +1,1027 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/node.ts
+/**
+* Builds a type guard that matches nodes of the given `kind`.
+*/
+function isKind(kind) {
+	return (node) => node.kind === kind;
+}
+/**
+* Updates a schema's `optional` and `nullish` flags from a parent's `required`
+* value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
+* object properties combine "required" and "nullable" into a single AST.
+*
+* - Non-required + non-nullable → `optional: true`.
+* - Non-required + nullable → `nullish: true`.
+* - Required → both flags cleared.
+*/
+function syncOptionality(schema, required) {
+	const nullable = schema.nullable ?? false;
+	return {
+		...schema,
+		optional: !required && !nullable ? true : void 0,
+		nullish: !required && nullable ? true : void 0
+	};
+}
+/**
+* Defines a node once and derives its `create` builder, `is` guard, and traversal
+* metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
+* `kind`, so node construction lives in one place without scattered `as` casts.
+*
+* Set `rebuild: true` when the `build` hook derives fields from children. After a
+* transform rewrites those children, the registry reruns `create` so the derived
+* fields stay correct.
+*
+* @example Simple node
+* ```ts
+* const importDef = defineNode<ImportNode>({ kind: 'Import' })
+* const createImport = importDef.create
+* ```
+*
+* @example Node with a build hook that is rerun on transform
+* ```ts
+* const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+*   kind: 'Property',
+*   build: (props) => ({ ...props, required: props.required ?? false }),
+*   children: ['schema'],
+*   visitorKey: 'property',
+*   rebuild: true,
+* })
+* ```
+*/
+function defineNode(config) {
+	const { kind, defaults, build, children, visitorKey, rebuild } = config;
+	function create(input) {
+		const base = build ? build(input) : input;
+		return {
+			...defaults,
+			...base,
+			kind
+		};
+	}
+	return {
+		kind,
+		create,
+		is: isKind(kind),
+		children,
+		visitorKey,
+		rebuild
+	};
+}
+//#endregion
+//#region src/nodes/schema.ts
+/**
+* Maps schema `type` to its underlying `primitive`.
+* Primitive types map to themselves. Special string formats map to `'string'`.
+* Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
+*/
+const TYPE_TO_PRIMITIVE = {
+	string: "string",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	boolean: "boolean",
+	null: "null",
+	any: "any",
+	unknown: "unknown",
+	void: "void",
+	never: "never",
+	object: "object",
+	array: "array",
+	date: "date",
+	uuid: "string",
+	email: "string",
+	url: "string",
+	datetime: "string",
+	time: "string"
+};
+/**
+* Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+* empty array, and `primitive` is inferred from `type` when not explicitly provided.
+*/
+const schemaDef = defineNode({
+	kind: "Schema",
+	build: (props) => {
+		if (props.type === "object") return {
+			properties: [],
+			primitive: "object",
+			...props
+		};
+		return {
+			primitive: TYPE_TO_PRIMITIVE[props.type],
+			...props
+		};
+	},
+	children: [
+		"properties",
+		"items",
+		"members",
+		"additionalProperties"
+	],
+	visitorKey: "schema"
+});
+function createSchema(props) {
+	return schemaDef.create(props);
+}
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region src/nodes/code.ts
+/**
+* Definition for the {@link ConstNode}.
+*/
+const constDef = defineNode({ kind: "Const" });
+/**
+* Creates a `ConstNode` representing a TypeScript `const` declaration.
+*
+* @example Exported constant with type and `as const`
+* ```ts
+* createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+* // export const pets: Pet[] = ... as const
+* ```
+*/
+const createConst = constDef.create;
+/**
+* Definition for the {@link TypeNode}.
+*/
+const typeDef = defineNode({ kind: "Type" });
+/**
+* Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+*
+* @example
+* ```ts
+* createType({ name: 'Pet', export: true })
+* // export type Pet = ...
+* ```
+*/
+const createType = typeDef.create;
+/**
+* Definition for the {@link FunctionNode}.
+*/
+const functionDef = defineNode({ kind: "Function" });
+/**
+* Creates a `FunctionNode` representing a TypeScript `function` declaration.
+*
+* @example
+* ```ts
+* createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+* // export async function fetchPet(): Promise<Pet> { ... }
+* ```
+*/
+const createFunction = functionDef.create;
+/**
+* Definition for the {@link ArrowFunctionNode}.
+*/
+const arrowFunctionDef = defineNode({ kind: "ArrowFunction" });
+/**
+* Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+*
+* @example
+* ```ts
+* createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+* // export const double = (n: number) => ...
+* ```
+*/
+const createArrowFunction = arrowFunctionDef.create;
+/**
+* Definition for the {@link TextNode}.
+*/
+const textDef = defineNode({
+	kind: "Text",
+	build: (value) => ({ value })
+});
+/**
+* Creates a {@link TextNode} representing a raw string fragment in the source output.
+*
+* @example
+* ```ts
+* createText('return fetch(id)')
+* // { kind: 'Text', value: 'return fetch(id)' }
+* ```
+*/
+const createText = textDef.create;
+/**
+* Definition for the {@link BreakNode}.
+*/
+const breakDef = defineNode({
+	kind: "Break",
+	build: () => ({})
+});
+/**
+* Creates a {@link BreakNode} representing a line break in the source output.
+*
+* @example
+* ```ts
+* createBreak()
+* // { kind: 'Break' }
+* ```
+*/
+function createBreak() {
+	return breakDef.create();
+}
+/**
+* Definition for the {@link JsxNode}.
+*/
+const jsxDef = defineNode({
+	kind: "Jsx",
+	build: (value) => ({ value })
+});
+/**
+* Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+*
+* @example
+* ```ts
+* createJsx('<>\n  <a href={href}>Open</a>\n</>')
+* // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+* ```
+*/
+const createJsx = jsxDef.create;
+//#endregion
+//#region src/nodes/content.ts
+/**
+* Definition for the {@link ContentNode}.
+*/
+const contentDef = defineNode({
+	kind: "Content",
+	children: ["schema"]
+});
+/**
+* Creates a `ContentNode` for a single request-body or response content type.
+*/
+const createContent = contentDef.create;
+//#endregion
+//#region src/nodes/file.ts
+/**
+* Definition for the {@link ImportNode}.
+*/
+const importDef = defineNode({ kind: "Import" });
+/**
+* Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+*
+* @example Named import
+* ```ts
+* createImport({ name: ['useState'], path: 'react' })
+* // import { useState } from 'react'
+* ```
+*/
+const createImport = importDef.create;
+/**
+* Definition for the {@link ExportNode}.
+*/
+const exportDef = defineNode({ kind: "Export" });
+/**
+* Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+*
+* @example Named export
+* ```ts
+* createExport({ name: ['Pet'], path: './Pet' })
+* // export { Pet } from './Pet'
+* ```
+*/
+const createExport = exportDef.create;
+/**
+* Definition for the {@link SourceNode}.
+*/
+const sourceDef = defineNode({ kind: "Source" });
+/**
+* Creates a `SourceNode` representing a fragment of source code within a file.
+*
+* @example
+* ```ts
+* createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+* ```
+*/
+const createSource = sourceDef.create;
+/**
+* Definition for the {@link FileNode}. The fully resolved builder lives in
+* `createFile`, so this definition only supplies the guard.
+*/
+const fileDef = defineNode({ kind: "File" });
+//#endregion
+//#region src/nodes/function.ts
+/**
+* Definition for the {@link TypeLiteralNode}.
+*/
+const typeLiteralDef = defineNode({ kind: "TypeLiteral" });
+/**
+* Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+*
+* @example
+* ```ts
+* createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+* // { petId: string }
+* ```
+*/
+const createTypeLiteral = typeLiteralDef.create;
+/**
+* Definition for the {@link IndexedAccessTypeNode}.
+*/
+const indexedAccessTypeDef = defineNode({ kind: "IndexedAccessType" });
+/**
+* Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+*
+* @example
+* ```ts
+* createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
+* // DeletePetPathParams['petId']
+* ```
+*/
+const createIndexedAccessType = indexedAccessTypeDef.create;
+/**
+* Definition for the {@link ObjectBindingPatternNode}.
+*/
+const objectBindingPatternDef = defineNode({ kind: "ObjectBindingPattern" });
+/**
+* Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+*
+* @example
+* ```ts
+* createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+* // { id, name }
+* ```
+*/
+const createObjectBindingPattern = objectBindingPatternDef.create;
+/**
+* Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
+* Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+* paired with a {@link TypeLiteralNode} type.
+*/
+const functionParameterDef = defineNode({
+	kind: "FunctionParameter",
+	build: (input) => {
+		if ("properties" in input) return {
+			name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),
+			type: createTypeLiteral({ members: input.properties.map((p) => ({
+				name: p.name,
+				type: p.type,
+				optional: p.optional ?? false
+			})) }),
+			optional: input.optional ?? false,
+			...input.default !== void 0 ? { default: input.default } : {}
+		};
+		return {
+			optional: false,
+			...input
+		};
+	}
+});
+/**
+* Creates a `FunctionParameterNode`. `optional` defaults to `false`.
+*
+* @example Optional param
+* ```ts
+* createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+* // → params?: QueryParams
+* ```
+*
+* @example Destructured group
+* ```ts
+* createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+* // → { id, name }: { id: string; name?: string } = {}
+* ```
+*/
+const createFunctionParameter = functionParameterDef.create;
+/**
+* Definition for the {@link FunctionParametersNode}.
+*/
+const functionParametersDef = defineNode({
+	kind: "FunctionParameters",
+	defaults: { params: [] }
+});
+/**
+* Creates a `FunctionParametersNode` from an ordered list of parameters.
+*
+* @example
+* ```ts
+* const empty = createFunctionParameters()
+* // { kind: 'FunctionParameters', params: [] }
+* ```
+*/
+function createFunctionParameters(props = {}) {
+	return functionParametersDef.create(props);
+}
+//#endregion
+//#region src/nodes/input.ts
+/**
+* Definition for the {@link InputNode}.
+*/
+const inputDef = defineNode({
+	kind: "Input",
+	defaults: {
+		schemas: [],
+		operations: [],
+		meta: {
+			circularNames: [],
+			enumNames: []
+		}
+	},
+	children: ["schemas", "operations"],
+	visitorKey: "input"
+});
+/**
+* Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+* `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
+* eager variant with array `schemas`/`operations` and the defaulted `meta`.
+*
+* @example Eager
+* ```ts
+* const input = createInput()
+* // { kind: 'Input', schemas: [], operations: [] }
+* ```
+*
+* @example Streaming
+* ```ts
+* const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
+* ```
+*/
+function createInput(options = {}) {
+	const { stream, ...overrides } = options;
+	if (stream) return {
+		kind: "Input",
+		...overrides
+	};
+	return inputDef.create(overrides);
+}
+//#endregion
+//#region src/nodes/requestBody.ts
+/**
+* Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
+*/
+const requestBodyDef = defineNode({
+	kind: "RequestBody",
+	build: (props) => ({
+		...props,
+		content: props.content?.map(createContent)
+	}),
+	children: ["content"]
+});
+/**
+* Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+*/
+const createRequestBody = requestBodyDef.create;
+//#endregion
+//#region src/nodes/operation.ts
+/**
+* Definition for the {@link OperationNode}. HTTP operations (those carrying both
+* `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
+* normalized into a `RequestBodyNode`.
+*/
+const operationDef = defineNode({
+	kind: "Operation",
+	build: (props) => {
+		const { requestBody, ...rest } = props;
+		const isHttp = rest.method !== void 0 && rest.path !== void 0;
+		return {
+			tags: [],
+			parameters: [],
+			responses: [],
+			...rest,
+			...isHttp ? { protocol: "http" } : {},
+			requestBody: requestBody ? createRequestBody(requestBody) : void 0
+		};
+	},
+	children: [
+		"parameters",
+		"requestBody",
+		"responses"
+	],
+	visitorKey: "operation"
+});
+function createOperation(props) {
+	return operationDef.create(props);
+}
+//#endregion
+//#region src/nodes/output.ts
+/**
+* Definition for the {@link OutputNode}.
+*/
+const outputDef = defineNode({
+	kind: "Output",
+	defaults: { files: [] },
+	visitorKey: "output"
+});
+/**
+* Creates an `OutputNode` with a stable default for `files`.
+*
+* @example
+* ```ts
+* const output = createOutput()
+* // { kind: 'Output', files: [] }
+* ```
+*/
+function createOutput(overrides = {}) {
+	return outputDef.create(overrides);
+}
+//#endregion
+//#region src/nodes/parameter.ts
+/**
+* Definition for the {@link ParameterNode}. `required` defaults to `false` and the
+* schema's `optional`/`nullish` flags are kept in sync with it.
+*/
+const parameterDef = defineNode({
+	kind: "Parameter",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: syncOptionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "parameter",
+	rebuild: true
+});
+/**
+* Creates a `ParameterNode`.
+*
+* @example
+* ```ts
+* const param = createParameter({
+*   name: 'petId',
+*   in: 'path',
+*   required: true,
+*   schema: createSchema({ type: 'string' }),
+* })
+* ```
+*/
+const createParameter = parameterDef.create;
+//#endregion
+//#region src/nodes/property.ts
+/**
+* Definition for the {@link PropertyNode}. `required` defaults to `false` and the
+* schema's `optional`/`nullish` flags are kept in sync with it.
+*/
+const propertyDef = defineNode({
+	kind: "Property",
+	build: (props) => {
+		const required = props.required ?? false;
+		return {
+			...props,
+			required,
+			schema: syncOptionality(props.schema, required)
+		};
+	},
+	children: ["schema"],
+	visitorKey: "property",
+	rebuild: true
+});
+/**
+* Creates a `PropertyNode`.
+*
+* @example
+* ```ts
+* const property = createProperty({
+*   name: 'status',
+*   required: true,
+*   schema: createSchema({ type: 'string', nullable: true }),
+* })
+* // required=true, no optional/nullish
+* ```
+*/
+const createProperty = propertyDef.create;
+//#endregion
+//#region src/nodes/response.ts
+/**
+* Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+* `mediaType`/`keysToOmit`) is normalized into one `content` entry.
+*/
+const responseDef = defineNode({
+	kind: "Response",
+	build: (props) => {
+		const { schema, mediaType, keysToOmit, content, ...rest } = props;
+		const entries = content ?? (schema ? [{
+			contentType: mediaType ?? "application/json",
+			schema,
+			keysToOmit: keysToOmit ?? null
+		}] : void 0);
+		return {
+			...rest,
+			content: entries?.map(createContent)
+		};
+	},
+	children: ["content"],
+	visitorKey: "response"
+});
+/**
+* Creates a `ResponseNode`.
+*
+* @example
+* ```ts
+* const response = createResponse({
+*   statusCode: '200',
+*   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+* })
+* ```
+*/
+const createResponse = responseDef.create;
+//#endregion
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__name", {
+	enumerable: true,
+	get: function() {
+		return __name;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "arrowFunctionDef", {
+	enumerable: true,
+	get: function() {
+		return arrowFunctionDef;
+	}
+});
+Object.defineProperty(exports, "breakDef", {
+	enumerable: true,
+	get: function() {
+		return breakDef;
+	}
+});
+Object.defineProperty(exports, "camelCase", {
+	enumerable: true,
+	get: function() {
+		return camelCase;
+	}
+});
+Object.defineProperty(exports, "constDef", {
+	enumerable: true,
+	get: function() {
+		return constDef;
+	}
+});
+Object.defineProperty(exports, "contentDef", {
+	enumerable: true,
+	get: function() {
+		return contentDef;
+	}
+});
+Object.defineProperty(exports, "createArrowFunction", {
+	enumerable: true,
+	get: function() {
+		return createArrowFunction;
+	}
+});
+Object.defineProperty(exports, "createBreak", {
+	enumerable: true,
+	get: function() {
+		return createBreak;
+	}
+});
+Object.defineProperty(exports, "createConst", {
+	enumerable: true,
+	get: function() {
+		return createConst;
+	}
+});
+Object.defineProperty(exports, "createContent", {
+	enumerable: true,
+	get: function() {
+		return createContent;
+	}
+});
+Object.defineProperty(exports, "createExport", {
+	enumerable: true,
+	get: function() {
+		return createExport;
+	}
+});
+Object.defineProperty(exports, "createFunction", {
+	enumerable: true,
+	get: function() {
+		return createFunction;
+	}
+});
+Object.defineProperty(exports, "createFunctionParameter", {
+	enumerable: true,
+	get: function() {
+		return createFunctionParameter;
+	}
+});
+Object.defineProperty(exports, "createFunctionParameters", {
+	enumerable: true,
+	get: function() {
+		return createFunctionParameters;
+	}
+});
+Object.defineProperty(exports, "createImport", {
+	enumerable: true,
+	get: function() {
+		return createImport;
+	}
+});
+Object.defineProperty(exports, "createIndexedAccessType", {
+	enumerable: true,
+	get: function() {
+		return createIndexedAccessType;
+	}
+});
+Object.defineProperty(exports, "createInput", {
+	enumerable: true,
+	get: function() {
+		return createInput;
+	}
+});
+Object.defineProperty(exports, "createJsx", {
+	enumerable: true,
+	get: function() {
+		return createJsx;
+	}
+});
+Object.defineProperty(exports, "createObjectBindingPattern", {
+	enumerable: true,
+	get: function() {
+		return createObjectBindingPattern;
+	}
+});
+Object.defineProperty(exports, "createOperation", {
+	enumerable: true,
+	get: function() {
+		return createOperation;
+	}
+});
+Object.defineProperty(exports, "createOutput", {
+	enumerable: true,
+	get: function() {
+		return createOutput;
+	}
+});
+Object.defineProperty(exports, "createParameter", {
+	enumerable: true,
+	get: function() {
+		return createParameter;
+	}
+});
+Object.defineProperty(exports, "createProperty", {
+	enumerable: true,
+	get: function() {
+		return createProperty;
+	}
+});
+Object.defineProperty(exports, "createRequestBody", {
+	enumerable: true,
+	get: function() {
+		return createRequestBody;
+	}
+});
+Object.defineProperty(exports, "createResponse", {
+	enumerable: true,
+	get: function() {
+		return createResponse;
+	}
+});
+Object.defineProperty(exports, "createSchema", {
+	enumerable: true,
+	get: function() {
+		return createSchema;
+	}
+});
+Object.defineProperty(exports, "createSource", {
+	enumerable: true,
+	get: function() {
+		return createSource;
+	}
+});
+Object.defineProperty(exports, "createText", {
+	enumerable: true,
+	get: function() {
+		return createText;
+	}
+});
+Object.defineProperty(exports, "createType", {
+	enumerable: true,
+	get: function() {
+		return createType;
+	}
+});
+Object.defineProperty(exports, "createTypeLiteral", {
+	enumerable: true,
+	get: function() {
+		return createTypeLiteral;
+	}
+});
+Object.defineProperty(exports, "defineNode", {
+	enumerable: true,
+	get: function() {
+		return defineNode;
+	}
+});
+Object.defineProperty(exports, "exportDef", {
+	enumerable: true,
+	get: function() {
+		return exportDef;
+	}
+});
+Object.defineProperty(exports, "fileDef", {
+	enumerable: true,
+	get: function() {
+		return fileDef;
+	}
+});
+Object.defineProperty(exports, "functionDef", {
+	enumerable: true,
+	get: function() {
+		return functionDef;
+	}
+});
+Object.defineProperty(exports, "functionParameterDef", {
+	enumerable: true,
+	get: function() {
+		return functionParameterDef;
+	}
+});
+Object.defineProperty(exports, "functionParametersDef", {
+	enumerable: true,
+	get: function() {
+		return functionParametersDef;
+	}
+});
+Object.defineProperty(exports, "importDef", {
+	enumerable: true,
+	get: function() {
+		return importDef;
+	}
+});
+Object.defineProperty(exports, "indexedAccessTypeDef", {
+	enumerable: true,
+	get: function() {
+		return indexedAccessTypeDef;
+	}
+});
+Object.defineProperty(exports, "inputDef", {
+	enumerable: true,
+	get: function() {
+		return inputDef;
+	}
+});
+Object.defineProperty(exports, "jsxDef", {
+	enumerable: true,
+	get: function() {
+		return jsxDef;
+	}
+});
+Object.defineProperty(exports, "objectBindingPatternDef", {
+	enumerable: true,
+	get: function() {
+		return objectBindingPatternDef;
+	}
+});
+Object.defineProperty(exports, "operationDef", {
+	enumerable: true,
+	get: function() {
+		return operationDef;
+	}
+});
+Object.defineProperty(exports, "outputDef", {
+	enumerable: true,
+	get: function() {
+		return outputDef;
+	}
+});
+Object.defineProperty(exports, "parameterDef", {
+	enumerable: true,
+	get: function() {
+		return parameterDef;
+	}
+});
+Object.defineProperty(exports, "pascalCase", {
+	enumerable: true,
+	get: function() {
+		return pascalCase;
+	}
+});
+Object.defineProperty(exports, "propertyDef", {
+	enumerable: true,
+	get: function() {
+		return propertyDef;
+	}
+});
+Object.defineProperty(exports, "requestBodyDef", {
+	enumerable: true,
+	get: function() {
+		return requestBodyDef;
+	}
+});
+Object.defineProperty(exports, "responseDef", {
+	enumerable: true,
+	get: function() {
+		return responseDef;
+	}
+});
+Object.defineProperty(exports, "schemaDef", {
+	enumerable: true,
+	get: function() {
+		return schemaDef;
+	}
+});
+Object.defineProperty(exports, "sourceDef", {
+	enumerable: true,
+	get: function() {
+		return sourceDef;
+	}
+});
+Object.defineProperty(exports, "syncOptionality", {
+	enumerable: true,
+	get: function() {
+		return syncOptionality;
+	}
+});
+Object.defineProperty(exports, "textDef", {
+	enumerable: true,
+	get: function() {
+		return textDef;
+	}
+});
+Object.defineProperty(exports, "typeDef", {
+	enumerable: true,
+	get: function() {
+		return typeDef;
+	}
+});
+Object.defineProperty(exports, "typeLiteralDef", {
+	enumerable: true,
+	get: function() {
+		return typeLiteralDef;
+	}
+});
+
+//# sourceMappingURL=response-hnSw2NKE.cjs.map