@kubb/adapter-oas 5.10.2 → 5.10.3

package/dist/index.d.cts

@@ -0,0 +1,1300 @@
+import { AdapterFactoryOptions, ast } from "@kubb/kit";
+//#region ../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
+// ==================================================================================================
+// JSON Schema Draft 04
+// ==================================================================================================
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
+ */
+type JSONSchema4TypeName = "string" //
+ | "number" | "integer" | "boolean" | "object" | "array" | "null" | "any";
+/**
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
+ */
+type JSONSchema4Type = string //
+ | number | boolean | JSONSchema4Object | JSONSchema4Array | null;
+// Workaround for infinite type recursion
+interface JSONSchema4Object {
+  [key: string]: JSONSchema4Type;
+}
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema4Array extends Array<JSONSchema4Type> {}
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-04/schema#'
+ * - 'http://json-schema.org/draft-04/hyper-schema#'
+ * - 'http://json-schema.org/draft-03/schema#'
+ * - 'http://json-schema.org/draft-03/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema4Version = string;
+/**
+ * JSON Schema V4
+ * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
+ */
+interface JSONSchema4 {
+  id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: JSONSchema4Version | undefined;
+  /**
+   * This attribute is a string that provides a short description of the
+   * instance property.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
+   */
+  title?: string | undefined;
+  /**
+   * This attribute is a string that provides a full description of the of
+   * purpose the instance property.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
+   */
+  description?: string | undefined;
+  default?: JSONSchema4Type | undefined;
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: boolean | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: boolean | undefined;
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  /**
+   * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
+   *
+   * This provides a definition for additional items in an array instance
+   * when tuple definitions of the items is provided.  This can be false
+   * to indicate additional items in the array are not allowed, or it can
+   * be a schema that defines the schema of the additional items.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
+   */
+  additionalItems?: boolean | JSONSchema4 | undefined;
+  /**
+   * This attribute defines the allowed items in an instance array, and
+   * MUST be a schema or an array of schemas.  The default value is an
+   * empty schema which allows any value for items in the instance array.
+   *
+   * When this attribute value is a schema and the instance value is an
+   * array, then all the items in the array MUST be valid according to the
+   * schema.
+   *
+   * When this attribute value is an array of schemas and the instance
+   * value is an array, each position in the instance array MUST conform
+   * to the schema in the corresponding position for this array.  This
+   * called tuple typing.  When tuple typing is used, additional items are
+   * allowed, disallowed, or constrained by the "additionalItems"
+   * (Section 5.6) attribute using the same rules as
+   * "additionalProperties" (Section 5.4) for objects.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
+   */
+  items?: JSONSchema4 | JSONSchema4[] | undefined;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  /**
+   * This attribute indicates if the instance must have a value, and not
+   * be undefined. This is false by default, making the instance
+   * optional.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
+   */
+  required?: boolean | string[] | undefined;
+  /**
+   * This attribute defines a schema for all properties that are not
+   * explicitly defined in an object type definition. If specified, the
+   * value MUST be a schema or a boolean. If false is provided, no
+   * additional properties are allowed beyond the properties defined in
+   * the schema. The default value is an empty schema which allows any
+   * value for additional properties.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
+   */
+  additionalProperties?: boolean | JSONSchema4 | undefined;
+  definitions?: {
+    [k: string]: JSONSchema4;
+  } | undefined;
+  /**
+   * This attribute is an object with property definitions that define the
+   * valid values of instance object property values. When the instance
+   * value is an object, the property values of the instance object MUST
+   * conform to the property definitions in this object. In this object,
+   * each property definition's value MUST be a schema, and the property's
+   * name MUST be the name of the instance property that it defines.  The
+   * instance property value MUST be valid according to the schema from
+   * the property definition. Properties are considered unordered, the
+   * order of the instance properties MAY be in any order.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
+   */
+  properties?: {
+    [k: string]: JSONSchema4;
+  } | undefined;
+  /**
+   * This attribute is an object that defines the schema for a set of
+   * property names of an object instance. The name of each property of
+   * this attribute's object is a regular expression pattern in the ECMA
+   * 262/Perl 5 format, while the value is a schema. If the pattern
+   * matches the name of a property on the instance object, the value of
+   * the instance's property MUST be valid against the pattern name's
+   * schema value.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
+   */
+  patternProperties?: {
+    [k: string]: JSONSchema4;
+  } | undefined;
+  dependencies?: {
+    [k: string]: JSONSchema4 | string[];
+  } | undefined;
+  /**
+   * This provides an enumeration of all possible values that are valid
+   * for the instance property. This MUST be an array, and each item in
+   * the array represents a possible value for the instance value. If
+   * this attribute is defined, the instance value MUST be one of the
+   * values in the array in order for the schema to be valid.
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
+   */
+  enum?: JSONSchema4Type[] | undefined;
+  /**
+   * A single type, or a union of simple types
+   */
+  type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
+  allOf?: JSONSchema4[] | undefined;
+  anyOf?: JSONSchema4[] | undefined;
+  oneOf?: JSONSchema4[] | undefined;
+  not?: JSONSchema4 | undefined;
+  /**
+   * The value of this property MUST be another schema which will provide
+   * a base schema which the current schema will inherit from.  The
+   * inheritance rules are such that any instance that is valid according
+   * to the current schema MUST be valid according to the referenced
+   * schema.  This MAY also be an array, in which case, the instance MUST
+   * be valid for all the schemas in the array.  A schema that extends
+   * another schema MAY define additional attributes, constrain existing
+   * attributes, or add other constraints.
+   *
+   * Conceptually, the behavior of extends can be seen as validating an
+   * instance against all constraints in the extending schema as well as
+   * the extended schema(s).
+   *
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
+   */
+  extends?: string | string[] | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
+   */
+  [k: string]: any;
+  format?: string | undefined;
+}
+// ==================================================================================================
+// JSON Schema Draft 06
+// ==================================================================================================
+type JSONSchema6TypeName = "string" //
+ | "number" | "integer" | "boolean" | "object" | "array" | "null" | "any";
+type JSONSchema6Type = string //
+ | number | boolean | JSONSchema6Object | JSONSchema6Array | null;
+// Workaround for infinite type recursion
+interface JSONSchema6Object {
+  [key: string]: JSONSchema6Type;
+}
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema6Array extends Array<JSONSchema6Type> {}
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-06/schema#'
+ * - 'http://json-schema.org/draft-06/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema6Version = string;
+/**
+ * JSON Schema V6
+ * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01
+ */
+type JSONSchema6Definition = JSONSchema6 | boolean;
+interface JSONSchema6 {
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: JSONSchema6Version | undefined;
+  /**
+   * Must be strictly greater than 0.
+   * A numeric instance is valid only if division by this keyword's value results in an integer.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
+   */
+  multipleOf?: number | undefined;
+  /**
+   * Representing an inclusive upper limit for a numeric instance.
+   * This keyword validates only if the instance is less than or exactly equal to "maximum".
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
+   */
+  maximum?: number | undefined;
+  /**
+   * Representing an exclusive upper limit for a numeric instance.
+   * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
+   */
+  exclusiveMaximum?: number | undefined;
+  /**
+   * Representing an inclusive lower limit for a numeric instance.
+   * This keyword validates only if the instance is greater than or exactly equal to "minimum".
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
+   */
+  minimum?: number | undefined;
+  /**
+   * Representing an exclusive lower limit for a numeric instance.
+   * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
+   */
+  exclusiveMinimum?: number | undefined;
+  /**
+   * Must be a non-negative integer.
+   * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
+   */
+  maxLength?: number | undefined;
+  /**
+   * Must be a non-negative integer.
+   * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
+   * Omitting this keyword has the same behavior as a value of 0.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
+   */
+  minLength?: number | undefined;
+  /**
+   * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
+   */
+  pattern?: string | undefined;
+  /**
+   * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
+   * Omitting this keyword has the same behavior as an empty schema.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
+   */
+  items?: JSONSchema6Definition | JSONSchema6Definition[] | undefined;
+  /**
+   * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
+   * If "items" is an array of schemas, validation succeeds if every instance element
+   * at a position greater than the size of "items" validates against "additionalItems".
+   * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
+   * (possibly the default value of an empty schema) is applied to all elements.
+   * Omitting this keyword has the same behavior as an empty schema.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
+   */
+  additionalItems?: JSONSchema6Definition | undefined;
+  /**
+   * Must be a non-negative integer.
+   * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
+   */
+  maxItems?: number | undefined;
+  /**
+   * Must be a non-negative integer.
+   * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
+   * Omitting this keyword has the same behavior as a value of 0.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
+   */
+  minItems?: number | undefined;
+  /**
+   * If this keyword has boolean value false, the instance validates successfully.
+   * If it has boolean value true, the instance validates successfully if all of its elements are unique.
+   * Omitting this keyword has the same behavior as a value of false.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
+   */
+  uniqueItems?: boolean | undefined;
+  /**
+   * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
+   */
+  contains?: JSONSchema6Definition | undefined;
+  /**
+   * Must be a non-negative integer.
+   * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
+   */
+  maxProperties?: number | undefined;
+  /**
+   * Must be a non-negative integer.
+   * An object instance is valid against "maxProperties" if its number of properties is greater than,
+   * or equal to, the value of this keyword.
+   * Omitting this keyword has the same behavior as a value of 0.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
+   */
+  minProperties?: number | undefined;
+  /**
+   * Elements of this array must be unique.
+   * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
+   * Omitting this keyword has the same behavior as an empty array.
+   *
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
+   */
+  required?: string[] | undefined;
+  /**
+   * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
+   * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
+   * the child instance for that name successfully validates against the corresponding schema.
+   * Omitting this keyword has the same behavior as an empty object.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
+   */
+  properties?: {
+    [k: string]: JSONSchema6Definition;
+  } | undefined;
+  /**
+   * This attribute is an object that defines the schema for a set of property names of an object instance.
+   * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
+   * If the pattern matches the name of a property on the instance object, the value of the instance's property
+   * MUST be valid against the pattern name's schema value.
+   * Omitting this keyword has the same behavior as an empty object.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
+   */
+  patternProperties?: {
+    [k: string]: JSONSchema6Definition;
+  } | undefined;
+  /**
+   * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
+   * If specified, the value MUST be a schema or a boolean.
+   * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
+   * The default value is an empty schema which allows any value for additional properties.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
+   */
+  additionalProperties?: JSONSchema6Definition | undefined;
+  /**
+   * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
+   * Each property specifies a dependency.
+   * If the dependency value is an array, each element in the array must be unique.
+   * Omitting this keyword has the same behavior as an empty object.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
+   */
+  dependencies?: {
+    [k: string]: JSONSchema6Definition | string[];
+  } | undefined;
+  /**
+   * Takes a schema which validates the names of all properties rather than their values.
+   * Note the property name that the schema is testing will always be a string.
+   * Omitting this keyword has the same behavior as an empty schema.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
+   */
+  propertyNames?: JSONSchema6Definition | undefined;
+  /**
+   * This provides an enumeration of all possible values that are valid
+   * for the instance property. This MUST be an array, and each item in
+   * the array represents a possible value for the instance value. If
+   * this attribute is defined, the instance value MUST be one of the
+   * values in the array in order for the schema to be valid.
+   *
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
+   */
+  enum?: JSONSchema6Type[] | undefined;
+  /**
+   * More readable form of a one-element "enum"
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
+   */
+  const?: JSONSchema6Type | undefined;
+  /**
+   * A single type, or a union of simple types
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
+   */
+  type?: JSONSchema6TypeName | JSONSchema6TypeName[] | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
+   */
+  allOf?: JSONSchema6Definition[] | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
+   */
+  anyOf?: JSONSchema6Definition[] | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
+   */
+  oneOf?: JSONSchema6Definition[] | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
+   */
+  not?: JSONSchema6Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
+   */
+  definitions?: {
+    [k: string]: JSONSchema6Definition;
+  } | undefined;
+  /**
+   * This attribute is a string that provides a short description of the instance property.
+   *
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
+   */
+  title?: string | undefined;
+  /**
+   * This attribute is a string that provides a full description of the of purpose the instance property.
+   *
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
+   */
+  description?: string | undefined;
+  /**
+   * This keyword can be used to supply a default JSON value associated with a particular schema.
+   * It is RECOMMENDED that a default value be valid against the associated schema.
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
+   */
+  default?: JSONSchema6Type | undefined;
+  /**
+   * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
+   */
+  examples?: JSONSchema6Type[] | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
+   */
+  format?: string | undefined;
+}
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7TypeName = "string" //
+ | "number" | "integer" | "boolean" | "object" | "array" | "null";
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7Type = string //
+ | number | boolean | JSONSchema7Object | JSONSchema7Array | null;
+// Workaround for infinite type recursion
+interface JSONSchema7Object {
+  [key: string]: JSONSchema7Type;
+}
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema7Version = string;
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+type JSONSchema7Definition = JSONSchema7 | boolean;
+interface JSONSchema7 {
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: JSONSchema7Version | undefined;
+  $comment?: string | undefined;
+  /**
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
+   */
+  $defs?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+   */
+  type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
+  enum?: JSONSchema7Type[] | undefined;
+  const?: JSONSchema7Type | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+   */
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+   */
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+   */
+  items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+  additionalItems?: JSONSchema7Definition | undefined;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  contains?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+   */
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: string[] | undefined;
+  properties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  patternProperties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  additionalProperties?: JSONSchema7Definition | undefined;
+  dependencies?: {
+    [key: string]: JSONSchema7Definition | string[];
+  } | undefined;
+  propertyNames?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+   */
+  if?: JSONSchema7Definition | undefined;
+  then?: JSONSchema7Definition | undefined;
+  else?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+   */
+  allOf?: JSONSchema7Definition[] | undefined;
+  anyOf?: JSONSchema7Definition[] | undefined;
+  oneOf?: JSONSchema7Definition[] | undefined;
+  not?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+   */
+  format?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+   */
+  contentMediaType?: string | undefined;
+  contentEncoding?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+   */
+  definitions?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+   */
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: JSONSchema7Type | undefined;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: JSONSchema7Type | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/openapi-types@12.1.3/node_modules/openapi-types/dist/index.d.ts
+declare namespace OpenAPIV3_1 {
+  type Modify<T, R> = Omit<T, keyof R> & R;
+  type PathsWebhooksComponents<T extends {} = {}> = {
+    paths: PathsObject<T>;
+    webhooks: Record<string, PathItemObject | ReferenceObject>;
+    components: ComponentsObject;
+  };
+  export type Document<T extends {} = {}> = Modify<Omit<OpenAPIV3.Document<T>, 'paths' | 'components'>, {
+    info: InfoObject;
+    jsonSchemaDialect?: string;
+    servers?: ServerObject[];
+  } & ((Pick<PathsWebhooksComponents<T>, 'paths'> & Omit<Partial<PathsWebhooksComponents<T>>, 'paths'>) | (Pick<PathsWebhooksComponents<T>, 'webhooks'> & Omit<Partial<PathsWebhooksComponents<T>>, 'webhooks'>) | (Pick<PathsWebhooksComponents<T>, 'components'> & Omit<Partial<PathsWebhooksComponents<T>>, 'components'>))>;
+  export type InfoObject = Modify<OpenAPIV3.InfoObject, {
+    summary?: string;
+    license?: LicenseObject;
+  }>;
+  export type ContactObject = OpenAPIV3.ContactObject;
+  export type LicenseObject = Modify<OpenAPIV3.LicenseObject, {
+    identifier?: string;
+  }>;
+  export type ServerObject = Modify<OpenAPIV3.ServerObject, {
+    url: string;
+    description?: string;
+    variables?: Record<string, ServerVariableObject>;
+  }>;
+  export type ServerVariableObject = Modify<OpenAPIV3.ServerVariableObject, {
+    enum?: [string, ...string[]];
+  }>;
+  export type PathsObject<T extends {} = {}, P extends {} = {}> = Record<string, (PathItemObject<T> & P) | undefined>;
+  export type HttpMethods = OpenAPIV3.HttpMethods;
+  export type PathItemObject<T extends {} = {}> = Modify<OpenAPIV3.PathItemObject<T>, {
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+  }> & { [method in HttpMethods]?: OperationObject<T>; };
+  export type OperationObject<T extends {} = {}> = Modify<OpenAPIV3.OperationObject<T>, {
+    parameters?: (ReferenceObject | ParameterObject)[];
+    requestBody?: ReferenceObject | RequestBodyObject;
+    responses?: ResponsesObject;
+    callbacks?: Record<string, ReferenceObject | CallbackObject>;
+    servers?: ServerObject[];
+  }> & T;
+  export type ExternalDocumentationObject = OpenAPIV3.ExternalDocumentationObject;
+  export type ParameterObject = OpenAPIV3.ParameterObject;
+  export type HeaderObject = OpenAPIV3.HeaderObject;
+  export type ParameterBaseObject = OpenAPIV3.ParameterBaseObject;
+  export type NonArraySchemaObjectType = OpenAPIV3.NonArraySchemaObjectType | 'null';
+  export type ArraySchemaObjectType = OpenAPIV3.ArraySchemaObjectType;
+  /**
+   * There is no way to tell typescript to require items when type is either 'array' or array containing 'array' type
+   * 'items' will be always visible as optional
+   * Casting schema object to ArraySchemaObject or NonArraySchemaObject will work fine
+   */
+  export type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject;
+  export interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+  }
+  export interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+  }
+  interface MixedSchemaObject extends BaseSchemaObject {
+    type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];
+    items?: ReferenceObject | SchemaObject;
+  }
+  export type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {
+    examples?: OpenAPIV3.BaseSchemaObject['example'][];
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    contentMediaType?: string;
+    $schema?: string;
+    additionalProperties?: boolean | ReferenceObject | SchemaObject;
+    properties?: {
+      [name: string]: ReferenceObject | SchemaObject;
+    };
+    allOf?: (ReferenceObject | SchemaObject)[];
+    oneOf?: (ReferenceObject | SchemaObject)[];
+    anyOf?: (ReferenceObject | SchemaObject)[];
+    not?: ReferenceObject | SchemaObject;
+    discriminator?: DiscriminatorObject;
+    externalDocs?: ExternalDocumentationObject;
+    xml?: XMLObject;
+    const?: any;
+  }>;
+  export type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;
+  export type XMLObject = OpenAPIV3.XMLObject;
+  export type ReferenceObject = Modify<OpenAPIV3.ReferenceObject, {
+    summary?: string;
+    description?: string;
+  }>;
+  export type ExampleObject = OpenAPIV3.ExampleObject;
+  export type MediaTypeObject = Modify<OpenAPIV3.MediaTypeObject, {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: Record<string, ReferenceObject | ExampleObject>;
+  }>;
+  export type EncodingObject = OpenAPIV3.EncodingObject;
+  export type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {
+    content: {
+      [media: string]: MediaTypeObject;
+    };
+  }>;
+  export type ResponsesObject = Record<string, ReferenceObject | ResponseObject>;
+  export type ResponseObject = Modify<OpenAPIV3.ResponseObject, {
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+    links?: {
+      [link: string]: ReferenceObject | LinkObject;
+    };
+  }>;
+  export type LinkObject = Modify<OpenAPIV3.LinkObject, {
+    server?: ServerObject;
+  }>;
+  export type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
+  export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;
+  export type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {
+    schemas?: Record<string, SchemaObject>;
+    responses?: Record<string, ReferenceObject | ResponseObject>;
+    parameters?: Record<string, ReferenceObject | ParameterObject>;
+    examples?: Record<string, ReferenceObject | ExampleObject>;
+    requestBodies?: Record<string, ReferenceObject | RequestBodyObject>;
+    headers?: Record<string, ReferenceObject | HeaderObject>;
+    securitySchemes?: Record<string, ReferenceObject | SecuritySchemeObject>;
+    links?: Record<string, ReferenceObject | LinkObject>;
+    callbacks?: Record<string, ReferenceObject | CallbackObject>;
+    pathItems?: Record<string, ReferenceObject | PathItemObject>;
+  }>;
+  export type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject;
+  export type HttpSecurityScheme = OpenAPIV3.HttpSecurityScheme;
+  export type ApiKeySecurityScheme = OpenAPIV3.ApiKeySecurityScheme;
+  export type OAuth2SecurityScheme = OpenAPIV3.OAuth2SecurityScheme;
+  export type OpenIdSecurityScheme = OpenAPIV3.OpenIdSecurityScheme;
+  export type TagObject = OpenAPIV3.TagObject;
+  export {};
+}
+declare namespace OpenAPIV3 {
+  interface Document<T extends {} = {}> {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject<T>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+    'x-express-openapi-validation-strict'?: boolean;
+  }
+  interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+  }
+  interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+  }
+  interface LicenseObject {
+    name: string;
+    url?: string;
+  }
+  interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+      [variable: string]: ServerVariableObject;
+    };
+  }
+  interface ServerVariableObject {
+    enum?: string[];
+    default: string;
+    description?: string;
+  }
+  interface PathsObject<T extends {} = {}, P extends {} = {}> {
+    [pattern: string]: (PathItemObject<T> & P) | undefined;
+  }
+  enum HttpMethods {
+    GET = "get",
+    PUT = "put",
+    POST = "post",
+    DELETE = "delete",
+    OPTIONS = "options",
+    HEAD = "head",
+    PATCH = "patch",
+    TRACE = "trace"
+  }
+  type PathItemObject<T extends {} = {}> = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+  } & { [method in HttpMethods]?: OperationObject<T>; };
+  type OperationObject<T extends {} = {}> = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ReferenceObject | ParameterObject)[];
+    requestBody?: ReferenceObject | RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: {
+      [callback: string]: ReferenceObject | CallbackObject;
+    };
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+  } & T;
+  interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+  }
+  interface ParameterObject extends ParameterBaseObject {
+    name: string;
+    in: string;
+  }
+  interface HeaderObject extends ParameterBaseObject {}
+  interface ParameterBaseObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+  }
+  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+  type ArraySchemaObjectType = 'array';
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+  interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+  }
+  interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+  }
+  interface BaseSchemaObject {
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    additionalProperties?: boolean | ReferenceObject | SchemaObject;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    properties?: {
+      [name: string]: ReferenceObject | SchemaObject;
+    };
+    allOf?: (ReferenceObject | SchemaObject)[];
+    oneOf?: (ReferenceObject | SchemaObject)[];
+    anyOf?: (ReferenceObject | SchemaObject)[];
+    not?: ReferenceObject | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+  }
+  interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+      [value: string]: string;
+    };
+  }
+  interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+  }
+  interface ReferenceObject {
+    $ref: string;
+  }
+  interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+  }
+  interface MediaTypeObject {
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    encoding?: {
+      [media: string]: EncodingObject;
+    };
+  }
+  interface EncodingObject {
+    contentType?: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+  }
+  interface RequestBodyObject {
+    description?: string;
+    content: {
+      [media: string]: MediaTypeObject;
+    };
+    required?: boolean;
+  }
+  interface ResponsesObject {
+    [code: string]: ReferenceObject | ResponseObject;
+  }
+  interface ResponseObject {
+    description: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+    links?: {
+      [link: string]: ReferenceObject | LinkObject;
+    };
+  }
+  interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+      [parameter: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+  }
+  interface CallbackObject {
+    [url: string]: PathItemObject;
+  }
+  interface SecurityRequirementObject {
+    [name: string]: string[];
+  }
+  interface ComponentsObject {
+    schemas?: {
+      [key: string]: ReferenceObject | SchemaObject;
+    };
+    responses?: {
+      [key: string]: ReferenceObject | ResponseObject;
+    };
+    parameters?: {
+      [key: string]: ReferenceObject | ParameterObject;
+    };
+    examples?: {
+      [key: string]: ReferenceObject | ExampleObject;
+    };
+    requestBodies?: {
+      [key: string]: ReferenceObject | RequestBodyObject;
+    };
+    headers?: {
+      [key: string]: ReferenceObject | HeaderObject;
+    };
+    securitySchemes?: {
+      [key: string]: ReferenceObject | SecuritySchemeObject;
+    };
+    links?: {
+      [key: string]: ReferenceObject | LinkObject;
+    };
+    callbacks?: {
+      [key: string]: ReferenceObject | CallbackObject;
+    };
+  }
+  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+  interface HttpSecurityScheme {
+    type: 'http';
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+  }
+  interface ApiKeySecurityScheme {
+    type: 'apiKey';
+    description?: string;
+    name: string;
+    in: string;
+  }
+  interface OAuth2SecurityScheme {
+    type: 'oauth2';
+    description?: string;
+    flows: {
+      implicit?: {
+        authorizationUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      password?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      clientCredentials?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+    };
+  }
+  interface OpenIdSecurityScheme {
+    type: 'openIdConnect';
+    description?: string;
+    openIdConnectUrl: string;
+  }
+  interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+  }
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Media type used to pick a schema from an operation's request or response.
+ *
+ * @example
+ * ```ts
+ * const ct: ContentType = 'application/vnd.api+json'
+ * ```
+ */
+type ContentType = 'application/json' | (string & {});
+/**
+ * Extended OpenAPI 3.0 schema object that includes OpenAPI 3.1 and JSON Schema fields.
+ * The parser uses these additional fields to handle newer spec versions.
+ *
+ * @example
+ * ```ts
+ * const schema: SchemaObject = {
+ *   type: 'string',
+ *   const: 'dog',
+ *   contentMediaType: 'application/octet-stream',
+ * }
+ * ```
+ */
+type SchemaObject$1 = {
+  externalDocs?: unknown;
+  xml?: unknown;
+  $schema?: string;
+  deprecated?: boolean;
+  example?: unknown;
+  examples?: Array<unknown>;
+  nullable?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  discriminator?: DiscriminatorObject$1;
+  'x-readme-ref-name'?: string;
+  /**
+   * OAS 3.0 vendor extension: marks a schema as nullable without using `type: ['null', ...]`.
+   */
+  'x-nullable'?: boolean;
+  /**
+   * OAS 3.1: constrains the schema to a single fixed value (equivalent to a one-item `enum`).
+   */
+  const?: string | number | boolean | null;
+  /**
+   * OAS 3.1: media type of the schema content. Raw `'application/octet-stream'` content maps to `blob`.
+   */
+  contentMediaType?: string;
+  /**
+   * OAS 3.1: encoding applied to string content, such as `base64`.
+   */
+  contentEncoding?: string;
+  $ref?: string;
+  /**
+   * OAS 3.1: positional tuple items, replacing the multi-item `items` array from OAS 3.0.
+   */
+  prefixItems?: Array<SchemaObject$1 | ReferenceObject$1>;
+  /**
+   * JSON Schema: maps regex patterns to sub-schemas for validating additional properties.
+   */
+  patternProperties?: Record<string, SchemaObject$1 | boolean>;
+  /**
+   * Single-schema form of `items`. Narrowed from the base type to take precedence over the tuple overload.
+   *
+   * Alongside `prefixItems`, the JSON Schema boolean form applies: `items: false` closes the tuple
+   * (no extra elements allowed), while `items: true` is equivalent to an unconstrained rest.
+   */
+  items?: SchemaObject$1 | ReferenceObject$1 | boolean;
+  /**
+   * Allowed values for this schema.
+   */
+  enum?: Array<string | number | boolean | null>;
+} & (OpenAPIV3_1.SchemaObject | JSONSchema4 | JSONSchema6 | JSONSchema7);
+/**
+ * Normalized OpenAPI document after parsing.
+ */
+type Document = OpenAPIV3_1.Document & Record<string, unknown>;
+/**
+ * Single operation object (the `get`/`post`/… entry on a path item) plus any vendor extensions.
+ */
+type OperationObject$1 = OpenAPIV3_1.OperationObject & Record<string, unknown>;
+/**
+ * Path item object holding the operations and shared parameters for a single URL path.
+ */
+type PathItemObject$1 = OpenAPIV3_1.PathItemObject;
+/**
+ * Discriminator object for `oneOf`/`anyOf` schemas in OpenAPI.
+ */
+type DiscriminatorObject$1 = OpenAPIV3_1.DiscriminatorObject;
+/**
+ * OpenAPI reference object pointing to a schema definition via `$ref`.
+ */
+type ReferenceObject$1 = OpenAPIV3_1.ReferenceObject;
+/**
+ * OpenAPI response object holding the content and headers for one status code.
+ */
+type ResponseObject$1 = OpenAPIV3_1.ResponseObject;
+/**
+ * OpenAPI media type object that maps a content-type string to its schema.
+ */
+type MediaTypeObject$1 = OpenAPIV3_1.MediaTypeObject;
+/**
+ * Selects which entry in the spec's `servers` array becomes the base URL and
+ * supplies values for its `{variable}` placeholders.
+ */
+type ServerOptions = {
+  /**
+   * Index into the `servers` array from your OpenAPI spec. Most projects pick
+   * `0` for the primary server. Omit to leave `baseURL` undefined.
+   */
+  index?: number;
+  /**
+   * Override values for `{variable}` placeholders in the selected server URL.
+   * Variables you do not provide use their `default` value from the spec.
+   */
+  variables?: Record<string, string>;
+};
+/**
+ * Configuration for the OpenAPI adapter: spec validation, content-type selection,
+ * server URL resolution, and how schema types are derived.
+ *
+ * @example
+ * ```ts
+ * adapterOas({
+ *   validate: false,
+ *   dateType: 'date',
+ *   server: { index: 0, variables: { env: 'prod' } },
+ * })
+ * ```
+ */
+type AdapterOasOptions = {
+  /**
+   * Validate the OpenAPI spec with `@readme/openapi-parser` before parsing. Each problem is
+   * reported as a `KUBB_INVALID_SPEC` warning and generation continues. Set to `false` to skip the
+   * check, which also makes generation faster on a large spec.
+   *
+   * @default true
+   */
+  validate?: boolean;
+  /**
+   * Media type to keep for request bodies and responses. Omit to keep every
+   * media type an operation declares.
+   */
+  contentType?: ContentType;
+  /**
+   * Selects the server entry used to compute the base URL for plugins that need
+   * it, and overrides its `{variable}` placeholders. Omit to leave `baseURL`
+   * undefined.
+   *
+   * @example
+   * ```ts
+   * // spec server: "https://api.{env}.example.com"
+   * server: { index: 0, variables: { env: 'prod' } }
+   * // → baseURL: "https://api.prod.example.com"
+   * ```
+   */
+  server?: ServerOptions;
+  /**
+   * How the `discriminator` field on `oneOf`/`anyOf` schemas is interpreted.
+   * - `'preserve'` child schemas stay exactly as written. The discriminator
+   *   narrows types at the call site but child shapes are not modified.
+   * - `'propagate'` Kubb pushes the discriminator property as a literal value
+   *   into each child schema, so each branch's discriminator field is precisely
+   *   typed.
+   *
+   * @default 'preserve'
+   */
+  discriminator?: 'preserve' | 'propagate';
+  /**
+   * Where inline enums live.
+   * - `'inline'` keeps each enum inline on the property that declares it.
+   * - `'root'` lifts every inline enum to a reusable top-level schema named after its context
+   *   (e.g. `PetStatusEnum`) and references it everywhere it appears.
+   *
+   * @default 'inline'
+   */
+  enums?: 'inline' | 'root';
+} & Partial<ast.ParserOptions>;
+/**
+ * Adapter options after defaults have been applied.
+ */
+type AdapterOasResolvedOptions = {
+  validate: boolean;
+  contentType: AdapterOasOptions['contentType'];
+  server: AdapterOasOptions['server'];
+  discriminator: NonNullable<AdapterOasOptions['discriminator']>;
+  enums: NonNullable<AdapterOasOptions['enums']>;
+  dateType: NonNullable<AdapterOasOptions['dateType']>;
+  integerType: NonNullable<AdapterOasOptions['integerType']>;
+  unknownType: NonNullable<AdapterOasOptions['unknownType']>;
+  emptySchemaType: NonNullable<AdapterOasOptions['emptySchemaType']>;
+  enumSuffix: NonNullable<AdapterOasOptions['enumSuffix']>;
+};
+/**
+ * `@kubb/core` adapter factory type for the OpenAPI adapter.
+ */
+type AdapterOas = AdapterFactoryOptions<'oas', AdapterOasOptions, AdapterOasResolvedOptions, Document>;
+//#endregion
+//#region src/adapter.d.ts
+/**
+ * The `name` of `@kubb/adapter-oas`, used to identify this adapter in a Kubb config.
+ */
+export declare const adapterOasName = "oas";
+/**
+ * Default Kubb adapter for OpenAPI 2.0, 3.0, and 3.1 specifications. Reads the
+ * spec from `input` (a file path, URL, inline content, or parsed object), validates
+ * it, resolves the base URL, and converts every schema and operation into the
+ * universal AST that every downstream plugin consumes.
+ *
+ * Configure once on `defineConfig`. The adapter's choices (date representation,
+ * integer width, server URL) apply to every plugin in the build.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ * import { adapterOas } from '@kubb/adapter-oas'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   adapter: adapterOas({
+ *     server: { index: 0 },
+ *     discriminator: 'propagate',
+ *     dateType: 'date',
+ *   }),
+ *   plugins: [pluginTs()],
+ * })
+ * ```
+ */
+export declare const adapterOas: import("@kubb/core").AdapterFactory<AdapterOas>;
+//#endregion
+//#region src/operation.d.ts
+/**
+ * A single OpenAPI operation: its path, method, raw operation object and resolved path item.
+ */
+type Operation = {
+  path: string;
+  method: string;
+  schema: OperationObject$1;
+  pathItem: PathItemObject$1;
+};
+//#endregion
+export type { AdapterOas, AdapterOasOptions, AdapterOasResolvedOptions, ContentType, DiscriminatorObject$1 as DiscriminatorObject, Document, MediaTypeObject$1 as MediaTypeObject, Operation, ReferenceObject$1 as ReferenceObject, ResponseObject$1 as ResponseObject, SchemaObject$1 as SchemaObject };
+//# sourceMappingURL=index.d.cts.map