@kubb/adapter-oas 5.0.0-alpha.10 → 5.0.0-alpha.12

package/dist/index.d.ts

@@ -100,6 +100,31 @@ declare class Oas extends BaseOas {
 }
 //#endregion
 //#region src/types.d.ts
+/**
+ * Controls how various OAS constructs are mapped to Kubb AST nodes.
+ */
+type ParserOptions = {
+  /**
+   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
+   */
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  /**
+   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
+   */
+  integerType?: 'number' | 'bigint';
+  /**
+   * AST type used when no schema type can be inferred.
+   */
+  unknownType: 'any' | 'unknown' | 'void';
+  /**
+   * AST type used for completely empty schemas (`{}`).
+   */
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  /**
+   * Suffix appended to derived enum names when building property schema names.
+   */
+  enumSuffix: 'enum' | (string & {});
+};
 type OasAdapterOptions = {
   /**
    * Validate the OpenAPI spec before parsing.
@@ -139,34 +164,16 @@ type OasAdapterOptions = {
    */
   discriminator?: 'strict' | 'inherit';
   /**
-   * Automatically resolve name collisions across schema components.
-   * @default false
+   * Enable collision detection for inline enum and schema type names.
+   * When `true` (default), full-path names are used and name collisions
+   * across schema components are automatically resolved (e.g. `OrderParamsStatusEnum`).
+   * When `false`, enum names use only the immediate property context
+   * (e.g. `ParamsStatusEnum`) matching the v4 naming conventions, with numeric
+   * suffixes for deduplication (e.g. `ParamsStatusEnum2`).
+   * @default true
    */
   collisionDetection?: boolean;
-  /**
-   * How `format: 'date-time'` schemas are represented in the AST.
-   * - `'string'` maps to a `datetime` string node.
-   * - `'date'` maps to a JavaScript `Date` node.
-   * - `false` falls through to a plain `string` node.
-   * @default 'string'
-   */
-  dateType?: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
-  /**
-   * Whether `type: 'integer'` / `format: 'int64'` produces `number` or `bigint` nodes.
-   * @default 'number'
-   */
-  integerType?: 'number' | 'bigint';
-  /**
-   * AST type used when no schema type can be inferred.
-   * @default 'any'
-   */
-  unknownType?: 'any' | 'unknown' | 'void';
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   * @default `unknownType`
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void';
-};
+} & Partial<ParserOptions>;
 type OasAdapterResolvedOptions = {
   validate: boolean;
   oasClass: OasAdapterOptions['oasClass'];
@@ -179,6 +186,7 @@ type OasAdapterResolvedOptions = {
   integerType: NonNullable<OasAdapterOptions['integerType']>;
   unknownType: NonNullable<OasAdapterOptions['unknownType']>;
   emptySchemaType: NonNullable<OasAdapterOptions['emptySchemaType']>;
+  enumSuffix: OasAdapterOptions['enumSuffix'];
   /**
    * Map from original `$ref` paths to their collision-resolved schema names.
    * Populated by the adapter after each `parse()` call.

package/dist/index.js

@@ -11,6 +11,110 @@ import swagger2openapi from "swagger2openapi";
 import jsonpointer from "jsonpointer";
 import BaseOas from "oas";
 import { matchesMimeType } from "oas/utils";
+//#region src/constants.ts
+/**
+* Default values for all `Options` fields.
+*/
+const DEFAULT_PARSER_OPTIONS = {
+	dateType: "string",
+	integerType: "number",
+	unknownType: "any",
+	emptySchemaType: "any",
+	enumSuffix: "enum"
+};
+/**
+* OpenAPI version string written into merged document stubs.
+*/
+const MERGE_OPENAPI_VERSION = "3.0.0";
+/**
+* Fallback `info.title` used when merging multiple API documents.
+*/
+const MERGE_DEFAULT_TITLE = "Merged API";
+/**
+* Fallback `info.version` used when merging multiple API documents.
+*/
+const MERGE_DEFAULT_VERSION = "1.0.0";
+/**
+* JSON Schema keywords that indicate structural composition.
+* A schema fragment containing any of these keys must not be inlined into its
+* parent during `allOf` flattening — it carries semantic meaning of its own.
+*/
+const structuralKeys = new Set([
+	"properties",
+	"items",
+	"additionalProperties",
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"not"
+]);
+/**
+* Maps OAS/JSON Schema `format` strings to their Kubb `SchemaType` equivalents.
+*
+* Only formats that need a type different from the raw OAS `type` are listed.
+* `int64`, `date-time`, `date`, and `time` are handled separately because their
+* mapping depends on runtime parser options.
+*
+* Note: `ipv4`, `ipv6`, and `hostname` map to `'url'` — the closest supported
+* scalar type in the Kubb AST, even though these are not strictly URLs.
+*/
+const formatMap = {
+	uuid: "uuid",
+	email: "email",
+	"idn-email": "email",
+	uri: "url",
+	"uri-reference": "url",
+	url: "url",
+	ipv4: "url",
+	ipv6: "url",
+	hostname: "url",
+	"idn-hostname": "url",
+	binary: "blob",
+	byte: "blob",
+	int32: "integer",
+	float: "number",
+	double: "number"
+};
+/**
+* Exhaustive list of media types that Kubb recognizes.
+*/
+const knownMediaTypes = new Set([
+	"application/json",
+	"application/xml",
+	"application/x-www-form-urlencoded",
+	"application/octet-stream",
+	"application/pdf",
+	"application/zip",
+	"application/graphql",
+	"multipart/form-data",
+	"text/plain",
+	"text/html",
+	"text/csv",
+	"text/xml",
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp",
+	"image/svg+xml",
+	"audio/mpeg",
+	"video/mp4"
+]);
+/**
+* Vendor extension keys used to attach human-readable labels to enum values.
+* Checked in priority order: the first key found wins.
+*/
+const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
+/**
+* Scalar primitive schema types used for union member simplification.
+*/
+const SCALAR_PRIMITIVE_TYPES = new Set([
+	"string",
+	"number",
+	"integer",
+	"bigint",
+	"boolean"
+]);
+//#endregion
 //#region src/oas/resolveServerUrl.ts
 /**
 * Resolves an OpenAPI server URL by substituting `{variable}` placeholders.
@@ -53,9 +157,12 @@ function toCamelOrPascal(text, pascal) {
 * Splits `text` on `.` and applies `transformPart` to each segment.
 * The last segment receives `isLast = true`, all earlier segments receive `false`.
 * Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
 */
 function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
+	const parts = text.split(/\.(?=[a-zA-Z])/);
 	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 /**
@@ -89,6 +196,27 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/names.ts
+/**
+* Returns a unique name by appending an incrementing numeric suffix when the name has already been used.
+* Mutates `data` in-place as a usage counter so subsequent calls remain consistent.
+*
+* @example
+* const seen: Record<string, number> = {}
+* getUniqueName('Foo', seen) // 'Foo'
+* getUniqueName('Foo', seen) // 'Foo2'
+* getUniqueName('Foo', seen) // 'Foo3'
+*/
+function getUniqueName(originalName, data) {
+	let used = data[originalName] || 0;
+	if (used) {
+		data[originalName] = ++used;
+		originalName += used;
+	}
+	data[originalName] = 1;
+	return originalName;
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * Returns `true` when `name` is a syntactically valid JavaScript variable name.
@@ -205,100 +333,6 @@ var URLPath = class {
 	}
 };
 //#endregion
-//#region src/constants.ts
-/**
-* OpenAPI version string written into merged document stubs.
-*/
-const MERGE_OPENAPI_VERSION = "3.0.0";
-/**
-* Fallback `info.title` used when merging multiple API documents.
-*/
-const MERGE_DEFAULT_TITLE = "Merged API";
-/**
-* Fallback `info.version` used when merging multiple API documents.
-*/
-const MERGE_DEFAULT_VERSION = "1.0.0";
-/**
-* JSON Schema keywords that indicate structural composition.
-* A schema fragment containing any of these keys must not be inlined into its
-* parent during `allOf` flattening — it carries semantic meaning of its own.
-*/
-const structuralKeys = new Set([
-	"properties",
-	"items",
-	"additionalProperties",
-	"oneOf",
-	"anyOf",
-	"allOf",
-	"not"
-]);
-/**
-* Maps OAS/JSON Schema `format` strings to their Kubb `SchemaType` equivalents.
-*
-* Only formats that need a type different from the raw OAS `type` are listed.
-* `int64`, `date-time`, `date`, and `time` are handled separately because their
-* mapping depends on runtime parser options.
-*
-* Note: `ipv4`, `ipv6`, and `hostname` map to `'url'` — the closest supported
-* scalar type in the Kubb AST, even though these are not strictly URLs.
-*/
-const formatMap = {
-	uuid: "uuid",
-	email: "email",
-	"idn-email": "email",
-	uri: "url",
-	"uri-reference": "url",
-	url: "url",
-	ipv4: "url",
-	ipv6: "url",
-	hostname: "url",
-	"idn-hostname": "url",
-	binary: "blob",
-	byte: "blob",
-	int32: "integer",
-	float: "number",
-	double: "number"
-};
-/**
-* Exhaustive list of media types that Kubb recognizes.
-*/
-const knownMediaTypes = new Set([
-	"application/json",
-	"application/xml",
-	"application/x-www-form-urlencoded",
-	"application/octet-stream",
-	"application/pdf",
-	"application/zip",
-	"application/graphql",
-	"multipart/form-data",
-	"text/plain",
-	"text/html",
-	"text/csv",
-	"text/xml",
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp",
-	"image/svg+xml",
-	"audio/mpeg",
-	"video/mp4"
-]);
-/**
-* Vendor extension keys used to attach human-readable labels to enum values.
-* Checked in priority order: the first key found wins.
-*/
-const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
-/**
-* Scalar primitive schema types used for union member simplification.
-*/
-const SCALAR_PRIMITIVE_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
-//#endregion
 //#region src/oas/Oas.ts
 /**
 * Prefix used to create synthetic `$ref` values for anonymous (inline) discriminator schemas.
@@ -1052,16 +1086,6 @@ function getImports({ node, nameMapping, resolve }) {
 //#endregion
 //#region src/parser.ts
 /**
-* Default values for all `Options` fields.
-*/
-const DEFAULT_OPTIONS = {
-	dateType: "string",
-	integerType: "number",
-	unknownType: "any",
-	emptySchemaType: "any",
-	enumSuffix: "enum"
-};
-/**
 * Looks up the Kubb `SchemaType` for a given OAS `format` string.
 * Returns `undefined` for formats not in `formatMap` (e.g. `int64`, `date-time`),
 * which are handled separately because their output depends on parser options.
@@ -1110,6 +1134,8 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		contentType,
 		collisionDetection
 	});
+	const usedEnumNames = {};
+	const isLegacyNaming = collisionDetection === false;
 	/**
 	* Maps an `'any' | 'unknown' | 'void'` option string to the corresponding `SchemaType` constant.
 	* Used for both `unknownType` (unannotated schemas) and `emptySchemaType` (empty `{}` schemas).
@@ -1156,7 +1182,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* Shared metadata fields included in every `createSchema` call.
 	* Centralizes the common properties so sub-handlers don't repeat them.
 	*/
-	function buildSchemaBase(schema, name, nullable, defaultValue) {
+	function renderSchemaBase(schema, name, nullable, defaultValue) {
 		return {
 			name,
 			nullable,
@@ -1264,7 +1290,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		return createSchema({
 			type: "intersection",
 			members: [...allOfMembers.slice(0, syntheticStart), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1278,23 +1304,23 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	function convertUnion({ schema, name, nullable, defaultValue, options }) {
 		const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
 		const unionBase = {
-			...buildSchemaBase(schema, name, nullable, defaultValue),
+			...renderSchemaBase(schema, name, nullable, defaultValue),
 			discriminatorPropertyName: isDiscriminator(schema) ? schema.discriminator.propertyName : void 0
 		};
 		if (schema.properties) {
 			const { oneOf: _oneOf, anyOf: _anyOf, ...schemaWithoutUnion } = schema;
 			const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
-			const memberBaseSchema = discriminator ? Object.fromEntries(Object.entries(schemaWithoutUnion).filter(([key]) => key !== "discriminator")) : schemaWithoutUnion;
+			const sharedPropertiesNode = convertSchema({
+				schema: discriminator ? Object.fromEntries(Object.entries(schemaWithoutUnion).filter(([key]) => key !== "discriminator")) : schemaWithoutUnion,
+				name: isLegacyNaming ? void 0 : name
+			}, options);
 			return createSchema({
 				type: "union",
 				...unionBase,
 				members: unionMembers.map((s) => {
 					const ref = isReference(s) ? s.$ref : void 0;
 					const discriminatorValue = discriminator?.mapping && ref ? Object.entries(discriminator.mapping).find(([, v]) => v === ref)?.[0] : void 0;
-					let propertiesNode = convertSchema({
-						schema: memberBaseSchema,
-						name
-					}, options);
+					let propertiesNode = sharedPropertiesNode;
 					if (discriminatorValue && discriminator) propertiesNode = applyDiscriminatorEnum({
 						node: propertiesNode,
 						propertyName: discriminator.propertyName,
@@ -1333,7 +1359,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			type: "enum",
 			primitive: getPrimitiveType(typeof constValue === "number" ? "number" : typeof constValue === "boolean" ? "boolean" : "string"),
 			enumValues: [constValue],
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1342,7 +1368,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* (i.e. `format: 'date-time'` with `dateType: false`).
 	*/
 	function convertFormat({ schema, name, nullable, defaultValue, mergedOptions }) {
-		const base = buildSchemaBase(schema, name, nullable, defaultValue);
+		const base = renderSchemaBase(schema, name, nullable, defaultValue);
 		if (schema.format === "int64") return createSchema({
 			type: mergedOptions.integerType === "bigint" ? "bigint" : "integer",
 			primitive: "integer",
@@ -1480,29 +1506,62 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* - not required + not nullable → `optional: true`
 	* - not required + nullable → `nullish: true`
 	*/
+	/**
+	* Builds the propagation name for a child property during recursive schema conversion.
+	*
+	* - **Legacy naming** (`isLegacyNaming`): only the immediate property key is used
+	*   (e.g. `Params` for property `params`), keeping nested names short.
+	* - **Default naming**: the parent name is prepended so the full path is encoded
+	*   (e.g. `OrderParams` when parent is `Order`).
+	*/
+	function resolveChildName(parentName, propName) {
+		if (isLegacyNaming) return pascalCase(propName);
+		return parentName ? pascalCase([parentName, propName].join(" ")) : void 0;
+	}
+	/**
+	* Derives the final name for an enum property schema node.
+	*
+	* The raw name always includes the enum suffix (e.g. `StatusEnum`).
+	* In legacy mode an additional deduplication step appends a numeric suffix
+	* when the same name has already been used (e.g. `ParamsStatusEnum2`).
+	*/
+	function resolveEnumPropName(parentName, propName, enumSuffix) {
+		const raw = pascalCase([
+			parentName,
+			propName,
+			enumSuffix
+		].filter(Boolean).join(" "));
+		return isLegacyNaming ? getUniqueName(raw, usedEnumNames) : raw;
+	}
+	/**
+	* Given a freshly-converted property schema, returns the node with a correct
+	* `name` attached — or stripped — depending on whether the node is a named
+	* enum, a boolean const-enum (always inlined), or a regular schema.
+	*/
+	function applyEnumName(propNode, parentName, propName, enumSuffix) {
+		const enumNode = narrowSchema(propNode, "enum");
+		if (enumNode?.primitive === "boolean") return {
+			...propNode,
+			name: void 0
+		};
+		if (enumNode) return {
+			...propNode,
+			name: resolveEnumPropName(parentName, propName, enumSuffix)
+		};
+		return propNode;
+	}
 	function convertObject({ schema, name, nullable, defaultValue, options, mergedOptions }) {
 		const properties = schema.properties ? Object.entries(schema.properties).map(([propName, propSchema]) => {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
 			const propNullable = isNullable(resolvedPropSchema);
-			const basePropName = name ? pascalCase([name, propName].join(" ")) : void 0;
-			const propNode = convertSchema({
-				schema: resolvedPropSchema,
-				name: basePropName
-			}, options);
-			const isEnumNode = !!narrowSchema(propNode, "enum");
-			const derivedPropName = isEnumNode && name ? pascalCase([
-				name,
-				propName,
-				mergedOptions.enumSuffix
-			].filter(Boolean).join(" ")) : basePropName;
 			return createProperty({
 				name: propName,
 				schema: {
-					...isEnumNode && derivedPropName !== basePropName ? {
-						...propNode,
-						name: derivedPropName
-					} : propNode,
+					...applyEnumName(convertSchema({
+						schema: resolvedPropSchema,
+						name: resolveChildName(name, propName)
+					}, options), name, propName, mergedOptions.enumSuffix),
 					nullable: propNullable || void 0,
 					optional: !required && !propNullable ? true : void 0,
 					nullish: !required && propNullable ? true : void 0
@@ -1524,7 +1583,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			properties,
 			additionalProperties: additionalPropertiesNode,
 			patternProperties,
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 		if (isDiscriminator(schema) && schema.discriminator.mapping) {
 			const discPropName = schema.discriminator.propertyName;
@@ -1532,11 +1591,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 				node: objectNode,
 				propertyName: discPropName,
 				values: Object.keys(schema.discriminator.mapping),
-				enumName: name ? pascalCase([
-					name,
-					discPropName,
-					mergedOptions.enumSuffix
-				].filter(Boolean).join(" ")) : void 0
+				enumName: name ? resolveEnumPropName(name, discPropName, mergedOptions.enumSuffix) : void 0
 			});
 		}
 		return objectNode;
@@ -1555,7 +1610,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			rest: schema.items ? convertSchema({ schema: schema.items }, options) : void 0,
 			min: schema.minItems,
 			max: schema.maxItems,
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1566,7 +1621,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	*/
 	function convertArray({ schema, name, nullable, defaultValue, options, mergedOptions }) {
 		const rawItems = schema.items;
-		const itemName = rawItems?.enum?.length && name ? pascalCase([name, mergedOptions.enumSuffix].join(" ")) : void 0;
+		const itemName = rawItems?.enum?.length && name ? resolveEnumPropName(void 0, name, mergedOptions.enumSuffix) : void 0;
 		return createSchema({
 			type: "array",
 			primitive: "array",
@@ -1577,7 +1632,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			min: schema.minItems,
 			max: schema.maxItems,
 			unique: schema.uniqueItems ?? void 0,
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1590,7 +1645,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			min: schema.minLength,
 			max: schema.maxLength,
 			pattern: schema.pattern,
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1604,7 +1659,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			max: schema.maximum,
 			exclusiveMinimum: typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : void 0,
 			exclusiveMaximum: typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0,
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1614,7 +1669,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		return createSchema({
 			type: "boolean",
 			primitive: "boolean",
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
 	/**
@@ -1649,7 +1704,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	*/
 	function convertSchema({ schema, name }, options) {
 		const mergedOptions = {
-			...DEFAULT_OPTIONS,
+			...DEFAULT_PARSER_OPTIONS,
 			...options
 		};
 		const flattenedSchema = flattenSchema(schema);
@@ -1680,7 +1735,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		if (schema.type === "string" && schema.contentMediaType === "application/octet-stream") return createSchema({
 			type: "blob",
 			primitive: "string",
-			...buildSchemaBase(schema, name, nullable, defaultValue)
+			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 		if (Array.isArray(schema.type) && schema.type.length > 1) {
 			const nonNullTypes = schema.type.filter((t) => t !== "null");
@@ -1694,7 +1749,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 					},
 					name
 				}, options)),
-				...buildSchemaBase(schema, name, arrayNullable, defaultValue)
+				...renderSchemaBase(schema, name, arrayNullable, defaultValue)
 			});
 		}
 		if (!type) {
@@ -1742,18 +1797,26 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	function parseOperation(options, oas, operation) {
 		const parameters = oas.getParameters(operation).map((param) => parseParameter(options, param));
 		const requestBodySchema = oas.getRequestSchema(operation);
-		const requestBody = requestBodySchema ? convertSchema({ schema: requestBodySchema }, options) : void 0;
+		const requestBodySchemaNode = requestBodySchema ? convertSchema({ schema: requestBodySchema }, options) : void 0;
+		const requestBodyKeysToOmit = requestBodySchema?.properties ? Object.entries(requestBodySchema.properties).filter(([, prop]) => !isReference(prop) && prop.readOnly).map(([key]) => key) : void 0;
+		const requestBody = requestBodySchemaNode ? {
+			schema: requestBodySchemaNode,
+			keysToOmit: requestBodyKeysToOmit?.length ? requestBodyKeysToOmit : void 0
+		} : void 0;
 		const responses = operation.getResponseStatusCodes().map((statusCode) => {
 			const responseObj = operation.getResponseByStatusCode(statusCode);
 			const responseSchema = oas.getResponseSchema(operation, statusCode);
 			const schema = responseSchema && Object.keys(responseSchema).length > 0 ? convertSchema({ schema: responseSchema }, options) : createSchema({ type: resolveTypeOption(options.emptySchemaType) });
 			const description = typeof responseObj === "object" && responseObj !== null && !Array.isArray(responseObj) ? responseObj.description : void 0;
 			const rawContent = typeof responseObj === "object" && responseObj !== null && !Array.isArray(responseObj) ? responseObj.content : void 0;
+			const mediaType = rawContent ? toMediaType(Object.keys(rawContent)[0] ?? "") : toMediaType(operation.contentType ?? "");
+			const keysToOmit = responseSchema?.properties ? Object.entries(responseSchema.properties).filter(([, prop]) => !isReference(prop) && prop.writeOnly).map(([key]) => key) : void 0;
 			return createResponse({
 				statusCode,
 				description,
 				schema,
-				mediaType: rawContent ? toMediaType(Object.keys(rawContent)[0] ?? "") : toMediaType(operation.contentType ?? "")
+				mediaType,
+				keysToOmit: keysToOmit?.length ? keysToOmit : void 0
 			});
 		});
 		return createOperation({
@@ -1775,7 +1838,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	*/
 	function parse(options) {
 		const mergedOptions = {
-			...DEFAULT_OPTIONS,
+			...DEFAULT_PARSER_OPTIONS,
 			...options
 		};
 		const schemas = Object.entries(schemaObjects).map(([name, schemaObject]) => convertSchema({
@@ -1845,7 +1908,7 @@ const adapterOasName = "oas";
 * ```
 */
 const adapterOas = createAdapter((options) => {
-	const { validate = true, oasClass, contentType, serverIndex, serverVariables, discriminator = "strict", collisionDetection = false, dateType = "string", integerType = "number", unknownType = "any", emptySchemaType = unknownType } = options;
+	const { validate = true, oasClass, contentType, serverIndex, serverVariables, discriminator = "strict", collisionDetection = true, dateType = DEFAULT_PARSER_OPTIONS.dateType, integerType = DEFAULT_PARSER_OPTIONS.integerType, unknownType = DEFAULT_PARSER_OPTIONS.unknownType, enumSuffix = DEFAULT_PARSER_OPTIONS.enumSuffix, emptySchemaType = unknownType || DEFAULT_PARSER_OPTIONS.emptySchemaType } = options;
 	const nameMapping = /* @__PURE__ */ new Map();
 	return {
 		name: "oas",
@@ -1861,6 +1924,7 @@ const adapterOas = createAdapter((options) => {
 			integerType,
 			unknownType,
 			emptySchemaType,
+			enumSuffix,
 			nameMapping
 		},
 		getImports(node, resolve) {
@@ -1893,7 +1957,8 @@ const adapterOas = createAdapter((options) => {
 					dateType,
 					integerType,
 					unknownType,
-					emptySchemaType
+					emptySchemaType,
+					enumSuffix
 				}),
 				meta: {
 					title: oas.api.info?.title,