@api-client/core 0.19.19 → 0.19.21

package/src/modeling/generators/oas_320/types.ts

@@ -0,0 +1,1259 @@
+import { type JSONSchema } from 'json-schema-typed/draft-2020-12'
+/**
+ * This is the root object of the [OpenAPI Description](#openapi-description-structure).
+ */
+export interface OpenApi320 {
+  /**
+   * This string MUST be the [version number](#versions-and-deprecation) of the OpenAPI Specification that the OpenAPI
+   * document uses. The `openapi` field SHOULD be used by tooling to interpret the OpenAPI document. This is _not_
+   * related to the [`info.version`](#info-version) string, which describes the OpenAPI document's version.
+   */
+  openapi: '3.2.0'
+  /**
+   * This string MUST be in the form of a URI reference as defined by [[RFC3986]] [Section
+   * 4.1](https://www.rfc-editor.org/rfc/rfc3986#section-4.1). The `$self` field provides the self-assigned URI of this
+   * document, which also serves as its base URI in accordance with [[RFC3986]] [Section
+   * 5.1.1](https://www.rfc-editor.org/rfc/rfc3986#section-5.1.1). Implementations MUST support identifying the targets
+   * of [API description URIs](#relative-references-in-api-description-uris) using the URI defined by this field when it
+   * is present. See [Establishing the Base URI](#establishing-the-base-uri) for the base URI behavior when `$self` is
+   * absent or relative, and see [Appendix F](#appendix-f-examples-of-base-uri-determination-and-reference-resolution)
+   * for examples of using `$self` to resolve references.
+   */
+  $self?: string
+  /**
+   * Provides metadata about the API. The metadata MAY be used by tooling as required.
+   */
+  info: InfoObject
+  /**
+   * The default value for the `$schema` keyword within [Schema Objects](#schema-object) contained within this OAS
+   * document. This MUST be in the form of a URI.
+   */
+  jsonSchemaDialect?: string
+  /**
+   * An array of Server Objects, which provide connectivity information to a target server. If the `servers` field is
+   * not provided, or is an empty array, the default value would be an array consisting of a single [Server
+   * Object](#server-object) with a [url](#server-url) value of `/`.
+   */
+  servers?: ServerObject[]
+  /**
+   * The available paths and operations for the API.
+   */
+  paths?: PathsObject
+  /**
+   * The incoming webhooks that MAY be received as part of this API and that the API consumer MAY choose to implement.
+   * Closely related to the `callbacks` feature, this section describes requests initiated other than by an API call,
+   * for example by an out of band registration. The key name is a unique string to refer to each webhook, while the
+   * (optionally referenced) Path Item Object describes a request that may be initiated by the API provider and the
+   * expected responses. An [example](https://learn.openapis.org/examples/v3.1/webhook-example.html) is available.
+   */
+  webhooks?: Record<string, PathItemObject>
+  /**
+   * An element to hold various Objects for the OpenAPI Description.
+   */
+  components?: ComponentsObject
+  /**
+   * A declaration of which security mechanisms can be used across the API. The list of values includes alternative
+   * Security Requirement Objects that can be used. Only one of the Security Requirement Objects need to be satisfied to
+   * authorize a request. Individual operations can override this definition. The list can be incomplete, up to being
+   * empty or absent. To make security explicitly optional, an empty security requirement (`{}`) can be included in the
+   * array.
+   */
+  security?: SecurityRequirementObject[]
+  /**
+   * A list of tags used by the OpenAPI Description with additional metadata. The order of the tags can be used to
+   * reflect on their order by the parsing tools. Not all tags that are used by the [Operation
+   * Object](#operation-object) must be declared. The tags that are not declared MAY be organized randomly or based on
+   * the tools' logic. Each tag name in the list MUST be unique.
+   */
+  tags?: TagObject[]
+  /**
+   * Additional external documentation.
+   */
+  externalDocs?: ExternalDocumentationObject
+}
+
+/**
+ * The object provides metadata about the API. The metadata MAY be used by the clients if needed, and MAY be presented
+ * in editing or documentation generation tools for convenience.
+ */
+export interface InfoObject {
+  /**
+   * The title of the API.
+   */
+  title: string
+  /**
+   * A short summary of the API.
+   */
+  summary?: string
+  /**
+   * A description of the API. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text
+   * representation.
+   */
+  description?: string
+  /**
+   * A URI for the Terms of Service for the API. This MUST be in the form of a URI.
+   */
+  termsOfService?: string
+  /**
+   * The contact information for the exposed API.
+   */
+  contact?: ContactObject
+  /**
+   * The license information for the exposed API.
+   */
+  license?: LicenseObject
+  /**
+   * The version of the OpenAPI document (which is distinct from the [OpenAPI Specification version](#oas-version) or
+   * the version of the API being described or the version of the OpenAPI Description).
+   */
+  version: string
+}
+
+/**
+ * Contact information for the exposed API.
+ */
+export interface ContactObject {
+  /**
+   * The identifying name of the contact person/organization.
+   */
+  name?: string
+  /**
+   * The URI for the contact information. This MUST be in the form of a URI.
+   */
+  url?: string
+  /**
+   * The email address of the contact person/organization. This MUST be in the form of an email address.
+   */
+  email?: string
+}
+
+/**
+ * License information for the exposed API.
+ */
+export interface LicenseObject {
+  /**
+   * The license name used for the API.
+   */
+  name: string
+  /**
+   * An [SPDX](https://spdx.org/licenses/) license expression for the API. The `identifier` field is mutually exclusive
+   * of the `url` field.
+   */
+  identifier?: string
+  /**
+   * A URI for the license used for the API. This MUST be in the form of a URI. The `url` field is mutually exclusive of
+   * the `identifier` field.
+   */
+  url?: string
+}
+
+/**
+ * An object representing a Server.
+ */
+export interface ServerObject {
+  /**
+   * A URL to the target host. This URL supports Server Variables and MAY be relative, to indicate that the host
+   * location is relative to the location where the document containing the Server Object is being served. Query and
+   * fragment MUST NOT be part of this URL. Variable substitutions will be made when a variable is named in
+   * `{`braces`}`.
+   */
+  url: string
+  /**
+   * An optional string describing the host designated by the URL. [CommonMark syntax](https://spec.commonmark.org/) MAY
+   * be used for rich text representation.
+   */
+  description?: string
+  /**
+   * An optional unique string to refer to the host designated by the URL.
+   */
+  name?: string
+  /**
+   * A map between a variable name and its value. The value is used for substitution in the server's URL template.
+   */
+  variables?: Record<string, ServerVariableObject>
+}
+
+/**
+ * An object representing a Server Variable for server URL template substitution. The server URL templating is defined
+ * by the following [ABNF](https://tools.ietf.org/html/rfc5234) syntax.
+ *
+ * ```abnf
+ * server-url-template  = 1*( literals / server-variable )
+ * server-variable      = "{" server-variable-name "}"
+ * server-variable-name = 1*( %x00-7A / %x7C / %x7E-10FFFF ) ; every Unicode character except { and }
+ * literals       = 1*( %x21 / %x23-24 / %x26-3B / %x3D / %x3F-5B
+ * / %x5D / %x5F / %x61-7A / %x7E / ucschar / iprivate
+ * / pct-encoded)
+ * ; any Unicode character except: CTL, SP,
+ * ;  DQUOTE, "%" (aside from pct-encoded),
+ * ;  "<", ">", "\", "^", "`", "{", "|", "}"
+ * pct-encoded    =  "%" HEXDIG HEXDIG
+ * ucschar        =  %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF
+ * /  %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD
+ * /  %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD
+ * /  %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD
+ * /  %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD
+ * /  %xD0000-DFFFD / %xE1000-EFFFD
+ * iprivate       =  %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD
+ * ```
+ *
+ * Here, `literals`, `pct-encoded`, `ucschar` and `iprivate` definitions are taken from [RFC
+ * 6570](https://www.rfc-editor.org/rfc/rfc6570), incorporating the corrections specified in [Errata
+ * 6937](https://www.rfc-editor.org/errata/eid6937) for `literals`. Each server variable MUST NOT appear more than once
+ * in the URL template. See the [Paths Object](#paths-object) for guidance on constructing full request URLs.
+ *
+ * ```abnf
+ * server-url-template  = 1*( literals / server-variable )
+ * server-variable      = "{" server-variable-name "}"
+ * server-variable-name = 1*( %x00-7A / %x7C / %x7E-10FFFF ) ; every Unicode character except { and }
+ * literals       = 1*( %x21 / %x23-24 / %x26-3B / %x3D / %x3F-5B
+ *                / %x5D / %x5F / %x61-7A / %x7E / ucschar / iprivate
+ *                / pct-encoded)
+ *                     ; any Unicode character except: CTL, SP,
+ *                     ;  DQUOTE, "%" (aside from pct-encoded),
+ *                     ;  "<", ">", "\", "^", "`", "{", "|", "}"
+ * pct-encoded    =  "%" HEXDIG HEXDIG
+ * ucschar        =  %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF
+ *                /  %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD
+ *                /  %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD
+ *                /  %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD
+ *                /  %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD
+ *                /  %xD0000-DFFFD / %xE1000-EFFFD
+ * iprivate       =  %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD
+ * ```
+ */
+export interface ServerVariableObject {
+  /**
+   * An enumeration of string values to be used if the substitution options are from a limited set. The array MUST NOT
+   * be empty.
+   */
+  enum?: string[]
+  /**
+   * The default value to use for substitution, which SHALL be sent if an alternate value is not_supplied. If the
+   * [`enum`](#server-variable-enum) is defined, the value MUST exist in the enum's values. Note that this behavior is
+   * different from the [Schema Object](#schema-object)'s `default` keyword, which documents the receiver's behavior
+   * rather than inserting the value into the data.
+   */
+  default: string
+  /**
+   * An optional description for the server variable. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for
+   * rich text representation.
+   */
+  description?: string
+}
+
+/**
+ * Holds a set of reusable objects for different aspects of the OAS. All objects defined within the Components Object
+ * will have no effect on the API unless they are explicitly referenced from outside the Components Object.
+ */
+export interface ComponentsObject {
+  /**
+   * An object to hold reusable [Schema Objects](#schema-object).
+   */
+  schemas?: Record<string, SchemaObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  responses?: Record<string, ResponseObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  parameters?: Record<string, ParameterObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  examples?: Record<string, ExampleObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  requestBodies?: Record<string, RequestBodyObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  headers?: Record<string, HeaderObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  links?: Record<string, LinkObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  callbacks?: Record<string, CallbackObject>
+  /**
+   * An object to hold reusable [Path Item Objects](#path-item-object).
+   */
+  pathItems?: Record<string, PathItemObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  mediaTypes?: Record<string, MediaTypeObject>
+}
+
+/**
+ * Holds the relative paths to the individual endpoints and their operations. The path is appended to the URL from the
+ * [Server Object](#server-object) in order to construct the full URL. The Paths Object MAY be empty, due to [Access
+ * Control List (ACL) constraints](#security-filtering). The key has a pattern: `/{path}`. A relative path to an
+ * individual endpoint. The field name MUST begin with a forward slash (`/`). The URL from the [Server
+ * Object](#server-object)'s `url` field, resolved and with template variables substituted, has the path **appended**
+ * (no relative URL resolution) to it in order to construct the full URL. [Path templating](#path-templating) is
+ * allowed. When matching URLs, concrete (non-templated) paths would be matched before their templated counterparts.
+ * Templated paths with the same hierarchy but different templated names MUST NOT exist as they are identical. In case
+ * of ambiguous matching, it's up to the tooling to decide which one to use.
+ */
+export type PathsObject = Record<string, PathItemObject>
+
+/**
+ * Describes the operations available on a single path. A Path Item MAY be empty, due to [ACL
+ * constraints](#security-filtering). The path itself is still exposed to the documentation viewer but they will not
+ * know which operations and parameters are available.
+ */
+export interface PathItemObject {
+  /**
+   * Allows for a referenced definition of this path item. The value MUST be in the form of a URI, and the referenced
+   * structure MUST be in the form of a [Path Item Object](#path-item-object). In case a Path Item Object field appears
+   * both in the defined object and the referenced object, the behavior is undefined. See the rules for resolving
+   * [Relative References](#relative-references-in-api-description-uris). _**Note:** The behavior of `$ref` with
+   * adjacent properties is likely to change in future versions of this specification to bring it into closer alignment
+   * with the behavior of the [Reference Object](#reference-object)._
+   */
+  $ref?: string
+  /**
+   * An optional string summary, intended to apply to all operations in this path.
+   */
+  summary?: string
+  /**
+   * An optional string description, intended to apply to all operations in this path. [CommonMark
+   * syntax](https://spec.commonmark.org/) MAY be used for rich text representation.
+   */
+  description?: string
+  /**
+   * A definition of a GET operation on this path.
+   */
+  get?: OperationObject
+  /**
+   * A definition of a PUT operation on this path.
+   */
+  put?: OperationObject
+  /**
+   * A definition of a POST operation on this path.
+   */
+  post?: OperationObject
+  /**
+   * A definition of a DELETE operation on this path.
+   */
+  delete?: OperationObject
+  /**
+   * A definition of a OPTIONS operation on this path.
+   */
+  options?: OperationObject
+  /**
+   * A definition of a HEAD operation on this path.
+   */
+  head?: OperationObject
+  /**
+   * A definition of a PATCH operation on this path.
+   */
+  patch?: OperationObject
+  /**
+   * A definition of a TRACE operation on this path.
+   */
+  trace?: OperationObject
+  /**
+   * A definition of a QUERY operation, as defined in the most recent IETF draft
+   * ([draft-ietf-httpbis-safe-method-w-body-08](https://www.ietf.org/archive/id/draft-ietf-httpbis-safe-method-w-body-11.html)
+   * as of this writing) or its RFC successor, on this path.
+   */
+  query?: OperationObject
+  /**
+   * A map of additional operations on this path. The map key is the HTTP method with the same capitalization that is to
+   * be sent in the request. This map MUST NOT contain any entry for the methods that can be defined by other fixed
+   * fields with Operation Object values (e.g. no `POST` entry, as the `post` field is used for this method).
+   */
+  additionalOperations?: Record<string, OperationObject>
+  /**
+   * An alternative `servers` array to service all operations in this path. If a `servers` array is specified at the
+   * [OpenAPI Object](#oas-servers) level, it will be overridden by this value.
+   */
+  servers?: ServerObject[]
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  parameters?: (ParameterObject | ReferenceObject)[]
+}
+
+/**
+ * Describes a single API operation on a path.
+ */
+export interface OperationObject {
+  /**
+   * A list of tags for API documentation control. Tags can be used for logical grouping of operations by resources or
+   * any other qualifier.
+   */
+  tags?: string[]
+  /**
+   * A short summary of what the operation does.
+   */
+  summary?: string
+  /**
+   * A verbose explanation of the operation behavior. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for
+   * rich text representation.
+   */
+  description?: string
+  /**
+   * Additional external documentation for this operation.
+   */
+  externalDocs?: ExternalDocumentationObject
+  /**
+   * Unique string used to identify the operation. The id MUST be unique among all operations described in the API. The
+   * operationId value is **case-sensitive**. Tools and libraries MAY use the operationId to uniquely identify an
+   * operation, therefore, it is RECOMMENDED to follow common programming naming conventions.
+   */
+  operationId?: string
+  /**
+   * A list of parameters that are applicable for this operation. If a parameter is already defined at the Path Item,
+   * the new definition will override it but can never remove it. The list MUST NOT include duplicated parameters. A
+   * unique parameter is defined by a combination of a name and location. The list can use the Reference Object to link
+   * to parameters that are defined in the OpenAPI Object’s components.parameters.
+   */
+  parameters?: (ParameterObject | ReferenceObject)[]
+  /**
+   * The request body applicable for this operation. The `requestBody` is fully supported in HTTP methods where the HTTP
+   * specification [[RFC9110](https://spec.openapis.org/oas/v3.2.0.html#bib-rfc9110)] [Section
+   * 9.3](https://datatracker.ietf.org/doc/html/rfc9110#section-9.3) has explicitly defined semantics for request
+   * bodies. In other cases where the HTTP spec discourages message content (such as GET and DELETE), `requestBody` is
+   * permitted but does not have well-defined semantics and SHOULD be avoided if possible.
+   */
+  requestBody?: RequestBodyObject | ReferenceObject
+  /**
+   * The list of possible responses as they are returned from executing this operation.
+   */
+  responses?: ResponsesObject
+  /**
+   * A map of possible out-of band callbacks related to the parent operation. The key is a unique identifier for the
+   * Callback Object. Each value in the map is a Callback Object that describes a request that may be initiated by the
+   * API provider and the expected responses.
+   */
+  callbacks?: Record<string, CallbackObject | ReferenceObject>
+  /**
+   * Declares this operation to be deprecated. Consumers SHOULD refrain from usage of the declared operation. Default
+   * value is `false`.
+   */
+  deprecated?: boolean
+  /**
+   * A declaration of which security mechanisms can be used for this operation. The list of values includes alternative
+   * Security Requirement Objects that can be used. Only one of the Security Requirement Objects need to be satisfied to
+   * authorize a request. To make security optional, an empty security requirement (`{}`) can be included in the array.
+   * This definition overrides any declared top-level [`security`](#oas-security). To remove a top-level security
+   * declaration, an empty array can be used.
+   */
+  security?: SecurityRequirementObject[]
+  /**
+   * An alternative `servers` array to service this operation. If a `servers` array is specified at the [Path Item
+   * Object](#path-item-servers) or [OpenAPI Object](#oas-servers) level, it will be overridden by this value.
+   */
+  servers?: ServerObject[]
+}
+
+/**
+ * Allows referencing an external resource for extended documentation.
+ */
+export interface ExternalDocumentationObject {
+  /**
+   * A description of the target documentation. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich
+   * text representation.
+   */
+  description?: string
+  /**
+   * The URI for the target documentation. This MUST be in the form of a URI.
+   */
+  url: string
+}
+
+/**
+ * An object grouping an internal or external example value with basic `summary` and `description` metadata. The
+ * examples can show either data suitable for schema validation, or serialized data as required by the containing [Media
+ * Type Object](#media-type-object), [Parameter Object](#parameter-object), or [Header Object](#header-object). This
+ * object is typically used in fields named `examples` (plural), and is a [referenceable](#reference-object) alternative
+ * to older `example` (singular) fields that do not support referencing or metadata. The various fields and types of
+ * examples are explained in more detail under [Working With Examples](#working-with-examples).
+ */
+export interface ExampleObject {
+  /**
+   * Short description for the example.
+   */
+  summary?: string
+  /**
+   * Long description for the example. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text
+   * representation.
+   */
+  description?: string
+  /**
+   * An example of the data structure that MUST be valid according to the relevant [Schema Object](#schema-object). If
+   * this field is present, `value` MUST be absent.
+   */
+  dataValue?: unknown
+  /**
+   * An example of the serialized form of the value, including encoding and escaping as described under [Validating
+   * Examples](#validating-examples). If `dataValue` is present, then this field SHOULD contain the serialization of the
+   * given data. Otherwise, it SHOULD be the valid serialization of a data value that itself MUST be valid as described
+   * for `dataValue`. This field SHOULD NOT be used if the serialization format is JSON, as the data form is easier to
+   * work with. If this field is present, `value`, and `externalValue` MUST be absent.
+   */
+  serializedValue?: string
+  /**
+   * A URI that identifies the serialized example in a separate document, allowing for values not easily or readably
+   * expressed as a Unicode string. If `dataValue` is present, then this field SHOULD identify a serialization of the
+   * given data. Otherwise, the value SHOULD be the valid serialization of a data value that itself MUST be valid as
+   * described for `dataValue`. If this field is present, `serializedValue` and `value` MUST be absent. See also the
+   * rules for resolving [Relative References](#relative-references-in-api-description-uris).
+   */
+  externalValue?: string
+  /**
+   * Embedded literal example. The `value` field and `externalValue` field are mutually exclusive. To represent examples
+   * of media types that cannot naturally be represented in JSON or YAML, use a string value to contain the example,
+   * escaping where necessary. **Deprecated for non-JSON serialization targets:** Use `dataValue` and/or
+   * `serializedValue`, which both have unambiguous syntax and semantics, instead.
+   */
+  value?: unknown
+}
+/**
+ * Describes a single operation parameter. A unique parameter is defined by a combination of a [name](#parameter-name)
+ * and [location](#parameter-in). See [Appendix E](#appendix-e-percent-encoding-and-form-media-types) for a detailed
+ * examination of percent-encoding concerns, including interactions with the `application/x-www-form-urlencoded` query
+ * string format.
+ */
+export interface ParameterObject {
+  /**
+   * The name of the parameter. Parameter names are _case-sensitive_. If [`in`](#parameter-in) is `"path"`, the `name`
+   * field MUST correspond to a single template expression occurring within the [path](#paths-path) field in the [Paths
+   * Object](#paths-object). See [Path Templating](#path-templating) for further information. If [`in`](#parameter-in)
+   * is `"header"` and the `name` field is `"Accept"`, `"Content-Type"` or `"Authorization"`, the parameter definition
+   * SHALL be ignored. If `in` is `"querystring"`, or for [certain combinations](#style-examples) of
+   * [`style`](#parameter-style) and [`explode`](#parameter-explode), the value of `name` is not used in the parameter
+   * serialization. For all other cases, the `name` corresponds to the parameter name used by the [`in`](#parameter-in)
+   * field.
+   */
+  name: string
+  /**
+   * The location of the parameter.
+   */
+  in: 'query' | 'querystring' | 'header' | 'path' | 'cookie'
+  /**
+   * A brief description of the parameter. This could contain examples of use. [CommonMark
+   * syntax](https://spec.commonmark.org/) MAY be used for rich text representation.
+   */
+  description?: string
+  /**
+   * Determines whether this parameter is mandatory. If the [parameter location](#parameter-in) is `"path"`, this field
+   * is **REQUIRED** and its value MUST be `true`. Otherwise, the field MAY be included and its default value is
+   * `false`.
+   */
+  required: boolean
+  /**
+   * Specifies that a parameter is deprecated and SHOULD be transitioned out of usage. Default value is `false`.
+   */
+  deprecated?: boolean
+  /**
+   * If `true`, clients MAY pass a zero-length string value in place of parameters that would otherwise be omitted
+   * entirely, which the server SHOULD interpret as the parameter being unused. Default value is `false`. If
+   * [`style`](#parameter-style) is used, and if [behavior is _n/a_ (cannot be serialized)](#style-examples), the value
+   * of `allowEmptyValue` SHALL be ignored. Interactions between this field and the parameter's [Schema
+   * Object](#schema-object) are implementation-defined. This field is valid only for `query` parameters.
+   * **Deprecated:** Use of this field is NOT RECOMMENDED, and it is likely to be removed in a later revision.
+   */
+  allowEmptyValue?: boolean
+  /**
+   * Example of the parameter's potential value; see [Working With Examples](#working-with-examples).
+   */
+  example?: unknown
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  examples?: Record<string, ExampleObject>
+  /**
+   * Describes how the parameter value will be serialized depending on the type of the parameter value. Default values
+   * (based on value of `in`):
+   *
+   * - For `"query"` - `"form"`
+   * - For `"path"` - `"simple"`
+   * - For `"header"` - `"simple"`
+   * - For `"cookie"` - `"form"` (for compatibility reasons; note that `style: "cookie"` SHOULD be used with `in:
+   *   "cookie"`; see [Appendix D](#appendix-d-serializing-headers-and-cookies) for details).
+   */
+  style?: string
+  /**
+   * When this is true, parameter values of type `array` or `object` generate separate parameters for each value of the
+   * array or key-value pair of the map. For other types of parameters, or when [`style`](#parameter-style) is
+   * `"deepObject"`, this field has no effect. When `style` is `"form"` or `"cookie"`, the default value is `true`. For
+   * all other styles, the default value is `false`.
+   */
+  explode?: boolean
+  /**
+   * When this is true, parameter values are serialized using reserved expansion, as defined by
+   * [RFC6570](https://datatracker.ietf.org/doc/html/rfc6570#section-3.2.3), which allows [RFC3986's reserved character
+   * set](https://datatracker.ietf.org/doc/html/rfc3986#section-2.2), as well as percent-encoded triples, to pass
+   * through unchanged, while still percent-encoding all other disallowed characters (including `%` outside of
+   * percent-encoded triples). Applications are still responsible for percent-encoding reserved characters that are not
+   * allowed by the rules of the `in` destination or media type, or are [not allowed in the path by this
+   * specification](#path-templating); see [URL Percent-Encoding](#url-percent-encoding) for details. The default value
+   * is `false`. This field only applies to `in` and `style` values that automatically percent-encode.
+   */
+  allowReserved?: boolean
+  /**
+   * The schema defining the type used for the parameter.
+   */
+  schema?: SchemaObject
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  content?: Record<string, MediaTypeObject>
+}
+
+/**
+ * Describes a single request body.
+ */
+export interface RequestBodyObject {
+  /**
+   * A brief description of the request body. This could contain examples of use. [CommonMark
+   * syntax](https://spec.commonmark.org/) MAY be used for rich text representation.
+   */
+  description?: string
+  /**
+   * The content of the request body. The key is a media type or media type range and the value describes it. The map
+   * SHOULD have at least one entry; if it does not, the behavior is implementation-defined. For requests that match
+   * multiple keys, only the most specific key is applicable. e.g. "text/plain" overrides "text/*"
+   */
+  content?: Record<string, MediaTypeObject | ReferenceObject>
+  /**
+   * Determines if the request body is required in the request. Defaults to `false`.
+   */
+  required?: boolean
+}
+
+/**
+ * Each Media Type Object describes content structured in accordance with the media type identified by its key. Multiple
+ * Media Type Objects can be used to describe content that can appear in any of several different media types. When
+ * `example` or `examples` are provided, the example SHOULD match the specified schema and be in the correct format as
+ * specified by the media type and its encoding. The `example` and `examples` fields are mutually exclusive. See
+ * [Working With Examples](#working-with-examples) for further guidance regarding the different ways of specifying
+ * examples, including non-JSON/YAML values.
+ */
+export interface MediaTypeObject {
+  /**
+   * A schema describing the complete content of the request, response, parameter, or header.
+   */
+  schema?: SchemaObject
+  /**
+   * A schema describing each item within a [sequential media type](#sequential-media-types).
+   */
+  itemSchema?: SchemaObject
+  /**
+   * Example of the media type; see [Working With Examples](#working-with-examples).
+   */
+  example?: unknown
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  examples?: Record<string, ExampleObject>
+  /**
+   * A map between a property name and its encoding information, as defined under [Encoding By Name](#encoding-by-name).
+   * The `encoding` field SHALL only apply when the media type is `multipart` or `application/x-www-form-urlencoded`. If
+   * no Encoding Object is provided for a property, the behavior is determined by the default values documented for the
+   * Encoding Object. This field MUST NOT be present if `prefixEncoding` or `itemEncoding` are present.
+   */
+  encoding?: Record<string, EncodingObject>
+  /**
+   * An array of positional encoding information, as defined under [Encoding By Position](#encoding-by-position). The
+   * `prefixEncoding` field SHALL only apply when the media type is `multipart`. If no Encoding Object is provided for a
+   * property, the behavior is determined by the default values documented for the Encoding Object. This field MUST NOT
+   * be present if `encoding` is present.
+   */
+  prefixEncoding?: EncodingObject[]
+  /**
+   * A single Encoding Object that provides encoding information for multiple array items, as defined under [Encoding By
+   * Position](#encoding-by-position). The `itemEncoding` field SHALL only apply when the media type is `multipart`. If
+   * no Encoding Object is provided for a property, the behavior is determined by the default values documented for the
+   * Encoding Object. This field MUST NOT be present if `encoding` is present.
+   */
+  itemEncoding?: EncodingObject
+}
+
+/**
+ * A single encoding definition applied to a single value, with the mapping of Encoding Objects to values determined by
+ * the [Media Type Object](#media-type-object) as described under [Encoding Usage and
+ * Restrictions](#encoding-usage-and-restrictions). See [Appendix B](#appendix-b-data-type-conversion) for a discussion
+ * of converting values of various types to string representations. See [Appendix
+ * E](#appendix-e-percent-encoding-and-form-media-types) for a detailed examination of percent-encoding concerns for
+ * form media types.
+ */
+export interface EncodingObject {
+  /**
+   * The `Content-Type` for encoding a specific property. The value is a comma-separated list, each element of which is
+   * either a specific media type (e.g. `image/png`) or a wildcard media type (e.g. `image/*`). The default value
+   * depends on the type as shown in the table below.
+   */
+  contentType?: string
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  headers?: Record<string, HeaderObject>
+  /**
+   * Applies nested Encoding Objects in the same manner as the [Media Type Object](#media-type-object)'s `encoding`
+   * field.
+   */
+  encoding?: Record<string, EncodingObject>
+  /**
+   * Applies nested Encoding Objects in the same manner as the [Media Type Object](#media-type-object)'s
+   * `prefixEncoding` field.
+   */
+  prefixEncoding?: EncodingObject[]
+  /**
+   * Applies nested Encoding Objects in the same manner as the [Media Type Object](#media-type-object)'s `itemEncoding`
+   * field.
+   */
+  itemEncoding?: EncodingObject
+  /**
+   * Describes how a specific property value will be serialized depending on its type. See [Parameter
+   * Object](#parameter-object) for details on the [`style`](#parameter-style) field. The behavior follows the same
+   * values as `query` parameters, including the default value of `"form"` which applies only when `contentType` is
+   * _not_ being used due to one or both of `explode` or `allowReserved` being explicitly specified. Note that the
+   * initial `?` used in query strings is not used in `application/x-www-form-urlencoded` message bodies, and MUST be
+   * removed (if using an RFC6570 implementation) or simply not added (if constructing the string manually). This field
+   * SHALL be ignored if the media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value
+   * is explicitly defined, then the value of [`contentType`](#encoding-content-type) (implicit or explicit) SHALL be
+   * ignored.
+   */
+  style?: string
+  /**
+   * When this is true, property values of type `array` or `object` generate separate parameters for each value of the
+   * array, or key-value-pair of the map. For other types of properties, or when [`style`](#encoding-style) is
+   * `"deepObject"`, this field has no effect. When `style` is `"form"`, the default value is `true`. For all other
+   * styles, the default value is `false`. This field SHALL be ignored if the media type is not
+   * `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of
+   * [`contentType`](#encoding-content-type) (implicit or explicit) SHALL be ignored.
+   */
+  explode?: boolean
+  /**
+   * When this is true, parameter values are serialized using reserved expansion, as defined by
+   * [RFC6570](https://datatracker.ietf.org/doc/html/rfc6570#section-3.2.3), which allows [RFC3986's reserved character
+   * set](https://datatracker.ietf.org/doc/html/rfc3986#section-2.2), as well as percent-encoded triples, to pass
+   * through unchanged, while still percent-encoding all other disallowed characters (including `%` outside of
+   * percent-encoded triples). Applications are still responsible for percent-encoding reserved characters that are not
+   * allowed in the target media type; see [URL Percent-Encoding](#url-percent-encoding) for details. The default value
+   * is `false`. This field SHALL be ignored if the media type is not `application/x-www-form-urlencoded` or
+   * `multipart/form-data`. If a value is explicitly defined, then the value of [`contentType`](#encoding-content-type)
+   * (implicit or explicit) SHALL be ignored.
+   */
+  allowReserved?: boolean
+}
+
+/**
+ * A container for the expected responses of an operation. The container maps a HTTP response code to the expected
+ * response. The documentation is not necessarily expected to cover all possible HTTP response codes because they may
+ * not be known in advance. However, documentation is expected to cover a successful operation response and any known
+ * errors. The `default` MAY be used as a default Response Object for all HTTP codes that are not covered individually
+ * by the Responses Object. The Responses Object MUST contain at least one response code, and if only one response code
+ * is provided it SHOULD be the response for a successful operation call.
+ */
+export interface ResponsesObject {
+  /**
+   * The documentation of responses other than the ones declared for specific HTTP response codes. Use this field to
+   * cover undeclared responses.
+   */
+  default?: ResponseObject | ReferenceObject
+  /**
+   * Pattern: [HTTP Status Code](#http-status-codes) Any HTTP status code can be used as the property name, but only one
+   * property per code, to describe the expected response for that HTTP status code. This field MUST be enclosed in
+   * quotation marks (for example, “200”) for compatibility between JSON and YAML. To define a range of response codes,
+   * this field MAY contain the uppercase wildcard character X. For example, 2XX represents all response codes between
+   * 200 and 299. Only the following range definitions are allowed: 1XX, 2XX, 3XX, 4XX, and 5XX. If a response is
+   * defined using an explicit code, the explicit code definition takes precedence over the range definition for that
+   * code.
+   */
+  [pattern: string]: ResponseObject | ReferenceObject | undefined
+}
+
+/**
+ * Describes a single response from an API operation, including design-time, static `links` to operations based on the
+ * response.
+ */
+export interface ResponseObject {
+  /**
+   * A short summary of the meaning of the response.
+   */
+  summary?: string
+  /**
+   * A description of the response. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text
+   * representation.
+   */
+  description?: string
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  headers?: Record<string, HeaderObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  content?: Record<string, MediaTypeObject>
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  links?: Record<string, LinkObject>
+}
+
+/**
+ * A map of possible out-of band callbacks related to the parent operation. Each value in the map is a [Path Item
+ * Object](#path-item-object) that describes a set of requests that may be initiated by the API provider and the
+ * expected responses. The key value used to identify the Path Item Object is an expression, evaluated at runtime, that
+ * identifies a URL to use for the callback operation. To describe incoming requests from the API provider independent
+ * from another API call, use the [`webhooks`](#oas-webhooks) field. Pattern: {expression} A Path Item Object used to
+ * define a callback request and expected responses. A [complete
+ * example](https://learn.openapis.org/examples/v3.0/callback-example.html) is available.
+ */
+export type CallbackObject = Record<string, PathItemObject>
+
+/**
+ * The Link Object represents a possible design-time link for a response. The presence of a link does not guarantee the
+ * caller's ability to successfully invoke it, rather it provides a known relationship and traversal mechanism between
+ * responses and other operations. Unlike _dynamic_ links (i.e. links provided **in** the response payload), the OAS
+ * linking mechanism does not require link information in the runtime response. For computing links and providing
+ * instructions to execute them, a [runtime expression](#runtime-expressions) is used for accessing values in an
+ * operation and using them as parameters while invoking the linked operation.
+ */
+export interface LinkObject {
+  /**
+   * A URI reference to an OAS operation. This field is mutually exclusive of the `operationId` field, and MUST point to
+   * an [Operation Object](#operation-object). Relative `operationRef` values MAY be used to locate an existing
+   * [Operation Object](#operation-object) in the OpenAPI Description.
+   */
+  operationRef?: string
+  /**
+   * The name of an _existing_, resolvable OAS operation, as defined with a unique `operationId`. This field is mutually
+   * exclusive of the `operationRef` field.
+   */
+  operationId?: string
+  /**
+   * A map representing parameters to pass to an operation as specified with operationId or identified via
+   * `operationRef`. The key is the parameter name to be used (optionally qualified with the parameter location, e.g.
+   * path.id for an id parameter in the path), whereas the value can be a constant or an expression to be evaluated and
+   * passed to the linked operation.
+   */
+  parameters?: Record<string, unknown>
+  /**
+   * [{expression}](#runtime-expressions)
+   */
+  requestBody?: unknown
+  /**
+   * A description of the link. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text
+   * representation.
+   */
+  description?: string
+  /**
+   * A server object to be used by the target operation.
+   */
+  server?: ServerObject
+}
+
+/**
+ * Describes a single header for [HTTP responses](#response-headers) and for [individual parts in `multipart`
+ * representations](#encoding-headers); see the relevant [Response Object](#response-object) and [Encoding
+ * Object](#encoding-object) documentation for restrictions on which headers can be described. The Header Object follows
+ * the structure of the [Parameter Object](#parameter-object), including determining its serialization strategy based on
+ * whether `schema` or `content` is present, with the following changes:
+ *
+ * 1. `name` MUST NOT be specified, it is given in the corresponding `headers` map.
+ * 2. `in` MUST NOT be specified, it is implicitly in `header`.
+ * 3. All traits that are affected by the location MUST be applicable to a location of `header` (for example,
+ *    [`style`](#parameter-style)). This means that `allowEmptyValue` MUST NOT be used, and `style`, if used, MUST be
+ *    limited to `"simple"`.
+ * 4. `name` MUST NOT be specified, it is given in the corresponding `headers` map.
+ * 5. `in` MUST NOT be specified, it is implicitly in `header`.
+ * 6. All traits that are affected by the location MUST be applicable to a location of `header` (for example,
+ *    [`style`](#parameter-style)). This means that `allowEmptyValue` MUST NOT be used, and `style`, if used, MUST be
+ *    limited to `"simple"`.
+ */
+export interface HeaderObject {
+  /**
+   * A brief description of the header. This could contain examples of use. [CommonMark
+   * syntax](https://spec.commonmark.org/) MAY be used for rich text representation.
+   */
+  description?: string
+  /**
+   * Determines whether this header is mandatory. The default value is `false`.
+   */
+  required?: boolean
+  /**
+   * Specifies that the header is deprecated and SHOULD be transitioned out of usage. Default value is `false`.
+   */
+  deprecated?: boolean
+  /**
+   * Example of the header's potential value; see [Working With Examples](#working-with-examples).
+   */
+  example?: unknown
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  examples?: Record<string, ExampleObject>
+  /**
+   * Describes how the header value will be serialized. The default (and only legal value for headers) is `"simple"`.
+   */
+  style?: string
+  /**
+   * When this is true, header values of type `array` or `object` generate a single header whose value is a
+   * comma-separated list of the array items or key-value pairs of the map, see [Style Examples](#style-examples). For
+   * other data types this field has no effect. The default value is `false`.
+   */
+  explode?: boolean
+  /**
+   * The schema defining the type used for the header.
+   */
+  schema?: SchemaObject
+  /**
+   * [Reference Object](#reference-object)]
+   */
+  content?: Record<string, MediaTypeObject>
+}
+
+/**
+ * Adds metadata to a single tag that is used by the [Operation Object](#operation-object). It is not mandatory to have
+ * a Tag Object per tag defined in the Operation Object instances.
+ */
+export interface TagObject {
+  /**
+   * The name of the tag. Use this value in the `tags` array of an Operation.
+   */
+  name: string
+  /**
+   * A short summary of the tag, used for display purposes.
+   */
+  summary?: string
+  /**
+   * A description for the tag. [CommonMark syntax](https://spec.commonmark.org/) MAY be used for rich text
+   * representation.
+   */
+  description?: string
+  /**
+   * Additional external documentation for this tag.
+   */
+  externalDocs?: ExternalDocumentationObject
+  /**
+   * The `name` of a tag that this tag is nested under. The named tag MUST exist in the API description, and circular
+   * references between parent and child tags MUST NOT be used.
+   */
+  parent?: string
+  /**
+   * A machine-readable string to categorize what sort of tag it is. Any string value can be used; common uses are `nav`
+   * for Navigation, `badge` for visible badges, `audience` for APIs used by different groups. A [registry of the most
+   * commonly used values](https://spec.openapis.org/registry/tag-kind/) is available.
+   */
+  kind?: string
+}
+
+/**
+ * A simple object to allow referencing other components in the OpenAPI Description, internally and externally. The
+ * `$ref` string value contains a URI [RFC3986](https://tools.ietf.org/html/rfc3986), which identifies the value being
+ * referenced. See the rules for resolving [Relative References](#relative-references-in-api-description-uris).
+ */
+export interface ReferenceObject {
+  /**
+   * The reference identifier. This MUST be in the form of a URI.
+   */
+  $ref: string
+  /**
+   * A short summary which by default SHOULD override that of the referenced component. If the referenced object-type
+   * does not allow a `summary` field, then this field has no effect.
+   */
+  summary?: string
+  /**
+   * A description which by default SHOULD override that of the referenced component. [CommonMark
+   * syntax](https://spec.commonmark.org/) MAY be used for rich text representation. If the referenced object-type does
+   * not allow a `description` field, then this field has no effect.
+   */
+  description?: string
+}
+
+/**
+ * The Schema Object allows the definition of input and output data types. These types can be objects, but also
+ * primitives and arrays. This object is a superset of the [JSON Schema Specification Draft
+ * 2020-12](https://www.ietf.org/archive/id/draft-bhutton-json-schema-01.html). The empty schema (which allows any
+ * instance to validate) MAY be represented by the boolean value `true` and a schema which allows no instance to
+ * validate MAY be represented by the boolean value `false`. For more information about the keywords, see [JSON Schema
+ * Core](https://www.ietf.org/archive/id/draft-bhutton-json-schema-01.html) and [JSON Schema
+ * Validation](https://www.ietf.org/archive/id/draft-bhutton-json-schema-validation-01.html). Unless stated otherwise,
+ * the keyword definitions follow those of JSON Schema and do not add any additional semantics; this includes keywords
+ * such as `$schema`, `$id`, `$ref`, and `$dynamicRef` being URIs rather than URLs. Where JSON Schema indicates that
+ * behavior is defined by the application (e.g. for annotations), OAS also defers the definition of semantics to the
+ * application consuming the OpenAPI document.
+ */
+export type SchemaObject = JSONSchema & {
+  /**
+   * The discriminator provides a "hint" for which of a set of schemas a payload is expected to satisfy. See
+   * [Composition and Inheritance](#composition-and-inheritance-polymorphism) for more details.
+   */
+  discriminator?: DiscriminatorObject
+  /**
+   * Adds additional metadata to describe the XML representation of this schema.
+   */
+  xml?: XMLObject
+  /**
+   * Additional external documentation for this schema.
+   */
+  externalDocs?: ExternalDocumentationObject
+  /**
+   * A free-form field to include an example of an instance for this schema. To represent examples that cannot be
+   * naturally represented in JSON or YAML, a string value can be used to contain the example with escaping where
+   * necessary. **Deprecated:** The `example` field has been deprecated in favor of the JSON Schema `examples` keyword.
+   * Use of `example` is discouraged, and later versions of this specification may remove it.
+   */
+  example?: unknown
+}
+
+/**
+ * When request bodies or response payloads may be one of a number of different schemas, these should use the JSON
+ * Schema `anyOf` or `oneOf` keywords to describe the possible schemas (see [Composition and
+ * Inheritance](#composition-and-inheritance-polymorphism)). A polymorphic schema MAY include a Discriminator Object,
+ * which defines the name of the property that may be used as a hint for which schema of the `anyOf` or `oneOf`, or
+ * which schema that references the current schema in an `allOf`, is expected to validate the structure of the model.
+ * This hint can be used to aid in serialization, deserialization, and validation. The Discriminator Object does this by
+ * implicitly or explicitly associating the possible values of a named property with alternative schemas. Note that
+ * `discriminator` MUST NOT change the validation outcome of the schema.
+ */
+export interface DiscriminatorObject {
+  /**
+   * The name of the discriminating property in the payload that will hold the discriminating value. The discriminating
+   * property MAY be defined as required or optional, but when defined as optional the Discriminator Object MUST include
+   * a `defaultMapping` field that specifies which schema is expected to validate the structure of the model when the
+   * discriminating property is not present.
+   */
+  propertyName: string
+  /**
+   * An object to hold mappings between payload values and schema names or URI references.
+   */
+  mapping?: Record<string, string>
+  /**
+   * The schema name or URI reference to a schema that is expected to validate the structure of the model when the
+   * discriminating property is not present in the payload or contains a value for which there is no explicit or
+   * implicit mapping.
+   */
+  defaultMapping?: string
+}
+
+/**
+ * A metadata object that allows for more fine-tuned XML model definitions. When using a Schema Object with XML, if no
+ * XML Object is present, the behavior is determined by the XML Object's default field values.
+ */
+export interface XMLObject {
+  /**
+   * One of `element`, `attribute`, `text`, `cdata`, or `none`, as explained under [XML Node Types](#xml-node-types).
+   * The default value is `none` if `$ref`, `$dynamicRef`, or `type: "array"` is present in the [Schema
+   * Object](#schema-object) containing the XML Object, and `element` otherwise.
+   */
+  nodeType?: string
+  /**
+   * Sets the name of the element/attribute corresponding to the schema, replacing the name that was inferred as
+   * described under [XML Node Names](#xml-node-names). This field SHALL be ignored if the `nodeType` is `text`,
+   * `cdata`, or `none`.
+   */
+  name?: string
+  /**
+   * The IRI ([[RFC3987]]) of the namespace definition. Value MUST be in the form of a non-relative IRI.
+   */
+  namespace?: string
+  /**
+   * The prefix to be used for the [name](#xml-name).
+   */
+  prefix?: string
+  /**
+   * Declares whether the property definition translates to an attribute instead of an element. Default value is
+   * `false`. If `nodeType` is present, this field MUST NOT be present. **Deprecated:** Use `nodeType: "attribute"`
+   * instead of `attribute: true`
+   */
+  attribute?: boolean
+  /**
+   * MAY be used only for an array definition. Signifies whether the array is wrapped (for example, `) or unwrapped (`).
+   *
+   * - Default value is `false`. The definition takes effect only when defined alongside `type` being `"array"` (outside
+   *   the `items`). If `nodeType` is present, this field MUST NOT be present. **Deprecated:** Use `nodeType: "element"`
+   *   instead of `wrapped: true`
+   * - Default value is `false`. The definition takes effect only when defined alongside `type` being `"array"` (outside
+   *   the `items`). If `nodeType` is present, this field MUST NOT be present. **Deprecated:** Use `nodeType: "element"`
+   *   instead of `wrapped: true`
+   */
+  wrapped?: boolean
+}
+
+/**
+ * Defines a security scheme that can be used by the operations. Supported schemes are HTTP authentication, an API key
+ * (either as a header, a cookie parameter or as a query parameter), mutual TLS (use of a client certificate), OAuth2's
+ * common flows (implicit, password, client credentials and authorization code) as defined in
+ * [RFC6749](https://tools.ietf.org/html/rfc6749), OAuth2 device authorization flow as defined in
+ * [RFC8628](https://tools.ietf.org/html/rfc8628), and [[OpenID-Connect-Core]]. Please note that as of 2020, the
+ * implicit flow is about to be deprecated by [OAuth 2.0 Security Best Current
+ * Practice](https://tools.ietf.org/html/draft-ietf-oauth-security-topics). Recommended for most use cases is
+ * Authorization Code Grant flow with PKCE.
+ */
+export type SecuritySchemeObject =
+  | HttpSecurityScheme
+  | ApiKeySecurityScheme
+  | OAuth2SecurityScheme
+  | OpenIdSecurityScheme
+
+interface SecuritySchemeBase {
+  description?: string
+  deprecated?: boolean
+}
+
+export interface HttpSecurityScheme extends SecuritySchemeBase {
+  type: 'http'
+  /**
+   * The name of the HTTP Authentication scheme to be used in the Authorization header as defined in [RFC9110] Section
+   * 16.4.1. The values used SHOULD be registered in the IANA Authentication Scheme registry. The value is
+   * case-insensitive, as defined in [RFC9110] Section 11.1.
+   */
+  scheme: 'Basic' | 'Bearer' | string
+  /**
+   * A hint to the client to identify how the bearer token is formatted. Bearer tokens are usually generated by an
+   * authorization server, so this information is primarily for documentation purposes.
+   */
+  bearerFormat?: string
+}
+
+export interface ApiKeySecurityScheme extends SecuritySchemeBase {
+  type: 'apiKey'
+  /**
+   * The name of the header, query or cookie parameter to be used.
+   */
+  name: string
+  /**
+   * The location of the API key.
+   */
+  in: 'query' | 'header' | 'cookie'
+}
+
+export interface OAuth2SecurityScheme extends SecuritySchemeBase {
+  type: 'oauth2'
+  /**
+   * An object containing configuration information for the flow types supported.
+   */
+  flows: OAuthFlowsObject
+}
+
+export interface OpenIdSecurityScheme extends SecuritySchemeBase {
+  type: 'openIdConnect'
+  /**
+   * OpenID Connect Discovery URL as defined by [OpenID-Connect-Discovery-1.0].
+   */
+  openIdConnectUrl: string
+}
+
+/**
+ * Allows configuration of the supported OAuth Flows.
+ */
+export interface OAuthFlowsObject {
+  /**
+   * Configuration for the OAuth Implicit flow
+   */
+  implicit?: ImplicitOAuthFlowObject
+  /**
+   * Configuration for the OAuth Resource Owner Password flow
+   */
+  password?: PasswordOAuthFlowObject
+  /**
+   * Configuration for the OAuth Client Credentials flow. Previously called `application` in OpenAPI 2.0.
+   */
+  clientCredentials?: ClientCredentialsOAuthFlowObject
+  /**
+   * Configuration for the OAuth Authorization Code flow. Previously called `accessCode` in OpenAPI 2.0.
+   */
+  authorizationCode?: AuthorizationCodeOAuthFlowObject
+  /**
+   * Configuration for the OAuth Device Authorization flow.
+   */
+  deviceAuthorization?: DeviceAuthorizationOAuthFlowObject
+}
+
+/**
+ * Configuration details for a supported OAuth Flow
+ */
+export interface OAuthFlowObject {
+  /**
+   * The authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the
+   * use of TLS. Applies To:
+   *
+   * - Implicit
+   * - AuthorizationCode
+   */
+  authorizationUrl?: string
+  /**
+   * The device authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard
+   * requires the use of TLS. Applies To:
+   *
+   * - DeviceAuthorization
+   */
+  deviceAuthorizationUrl?: string
+  /**
+   * The device authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard
+   * requires the use of TLS. Applies To:
+   *
+   * - Password
+   * - ClientCredentials
+   * - AuthorizationCode
+   * - DeviceAuthorization
+   */
+  tokenUrl?: string
+  /**
+   * The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires
+   * the use of TLS.
+   */
+  refreshUrl?: string
+  /**
+   * The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it.
+   * The map MAY be empty.
+   */
+  scopes: Record<string, string>
+}
+
+export interface ImplicitOAuthFlowObject extends OAuthFlowObject {
+  authorizationUrl: string
+}
+
+export interface AuthorizationCodeOAuthFlowObject extends OAuthFlowObject {
+  authorizationUrl: string
+  tokenUrl: string
+}
+
+export interface PasswordOAuthFlowObject extends OAuthFlowObject {
+  tokenUrl: string
+}
+
+export interface ClientCredentialsOAuthFlowObject extends OAuthFlowObject {
+  tokenUrl: string
+}
+
+export interface DeviceAuthorizationOAuthFlowObject extends OAuthFlowObject {
+  deviceAuthorizationUrl: string
+  tokenUrl: string
+}
+
+/**
+ * Lists the required security schemes to execute this operation. The name used for each property MUST either correspond
+ * to a security scheme declared in the [Security Schemes](#components-security-schemes) under the [Components
+ * Object](#components-object), or be the URI of a Security Scheme Object. Property names that are identical to a
+ * component name under the Components Object MUST be treated as a component name. To reference a Security Scheme with a
+ * single-segment relative URI reference (e.g. `foo`) that collides with a component name (e.g.
+ * `#/components/securitySchemes/foo`), use the `.` path segment (e.g. `./foo`). Using a Security Scheme component name
+ * that appears to be a URI is NOT RECOMMENDED, as the precedence of component-name-matching over URI resolution, which
+ * is necessary to maintain compatibility with prior OAS versions, is counter-intuitive. See also [Security
+ * Considerations](#security-considerations). A Security Requirement Object MAY refer to multiple security schemes in
+ * which case all schemes MUST be satisfied for a request to be authorized. This enables support for scenarios where
+ * multiple query parameters or HTTP headers are required to convey security information. When the `security` field is
+ * defined on the [OpenAPI Object](#openapi-object) or [Operation Object](#operation-object) and contains multiple
+ * Security Requirement Objects, only one of the entries in the list needs to be satisfied to authorize the request.
+ * This enables support for scenarios where the API allows multiple, independent security schemes. An empty Security
+ * Requirement Object (`{}`) indicates anonymous access is supported.
+ */
+export type SecurityRequirementObject = Record<string, string[]>