openapi-specification-types 0.0.4 → 0.3.0

package/README.md

@@ -0,0 +1,74 @@
+# openapi-specification-types
+
+TypeScript type definitions for [OpenAPI (Swagger) 2.0](https://swagger.io/specification/v2/) and [OpenAPI 3.x](https://spec.openapis.org/oas/v3.2.0) specifications.
+
+## Install
+
+```bash
+pnpm add openapi-specification-types
+# or
+npm i openapi-specification-types
+```
+
+## Usage
+
+```ts
+import type {
+  OpenAPISpecificationV2,
+  OpenAPISpecificationV3,
+  Parameter,
+  Paths,
+  Schema,
+  Tag,
+} from 'openapi-specification-types'
+
+// OpenAPI 2.0 (Swagger) — required: swagger, info (title, version), paths
+const v2: OpenAPISpecificationV2 = {
+  swagger: '2.0',
+  info: { title: 'API', version: '1.0' },
+  paths: {},
+}
+
+// OpenAPI 3.x — required: openapi, info, externalDocs, servers, tags, paths, components
+const v3: OpenAPISpecificationV3 = {
+  openapi: '3.0.0',
+  info: {
+    title: 'API',
+    version: '1.0',
+    description: '',
+    termsOfService: '',
+    contact: { name: '', url: '', email: '' },
+    license: { name: '', url: '' },
+  },
+  externalDocs: { description: '', url: '' },
+  servers: [],
+  tags: [],
+  paths: {},
+  components: { schemas: {}, requestBodies: {} },
+}
+```
+
+## Exported types
+
+- **OpenAPI 2.0**: `OpenAPISpecificationV2`, `InfoV2`, `ContactV2`, `LicenseV2`, `ExternalDocsV2`, `Definitions`, `SecurityDefinitions`, `PathsV2`, etc.
+- **OpenAPI 3.x**: `OpenAPISpecificationV3`, `Components`, `Server`, `RequestBody`, `SecurityScheme`, etc.
+- **Shared**: `Schema`, `Paths`, `Parameter`, `Tag`, `Method`, `Responses`, `RequestBody`, `AnyObject`, etc.
+
+## Scripts
+
+| Command | Description |
+|---------|-------------|
+| `pnpm run typecheck` | TypeScript type check |
+| `pnpm run test` | Run Vitest (runtime + type tests) |
+| `pnpm run lint` | Run ESLint |
+
+## Testing
+
+Tests include:
+
+- **Runtime tests** (`test/*.test.ts`): value checks with Vitest.
+- **Type tests** (`test/*.test-d.ts`): compile-time checks with `expectTypeOf` / `assertType`; run via `pnpm test` (uses `vitest --typecheck`).
+
+## License
+
+ISC

package/dist/index.d.mts

@@ -0,0 +1,595 @@
+//#region src/common.d.ts
+interface StringObject {
+  [key: string]: string;
+}
+interface AnyObject {
+  [key: string]: any;
+}
+/** JSON Reference — used for $ref in Swagger 2.0 / OpenAPI (parameter, response, path, schema). */
+interface Reference {
+  $ref: string;
+  /** OpenAPI 3.x: override referenced component summary. */
+  summary?: string;
+  /** OpenAPI 3.x: override referenced component description. */
+  description?: string;
+}
+/** Security Requirement — scheme name to list of scopes ([] for apiKey/http/mutualTLS). Shared by Swagger 2.0 and OpenAPI 3.x. */
+interface SecurityRequirement {
+  [schemeName: string]: string[];
+}
+/** Contact Object — optional contact for the API (Swagger 2.0 / OpenAPI 3.x). */
+interface Contact {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+/** License Object — name required when present; identifier/url optional (OpenAPI 3.x); v2 uses name + url only. */
+interface License {
+  name: string;
+  identifier?: string;
+  url?: string;
+}
+/** Info Object — API metadata; title and version required (Swagger 2.0 / OpenAPI 3.x). */
+interface Info {
+  title: string;
+  version: string;
+  summary?: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: Contact;
+  license?: License;
+}
+//#endregion
+//#region src/schema.d.ts
+/** JSON Schema / Swagger 2.0 primitive types; file for Parameter/Response only; null for JSON Schema 2020-12 (OpenAPI 3.x). */
+type SchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'file' | 'null';
+interface Schema {
+  $ref?: string;
+  format?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  type?: SchemaType | SchemaType[];
+  /** JSON Schema validation. */
+  multipleOf?: number;
+  maximum?: number;
+  minimum?: number;
+  exclusiveMaximum?: boolean;
+  exclusiveMinimum?: boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  enum?: unknown[];
+  items?: Schema;
+  allOf?: Schema[];
+  properties?: Properties;
+  additionalProperties?: Schema | boolean;
+  /** Swagger 2.0: polymorphism; property name in required; value = definition name. */
+  discriminator?: string;
+  /** Swagger 2.0: property only in response. */
+  readOnly?: boolean;
+  /** Swagger 2.0: example instance. */
+  example?: unknown;
+  xml?: {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+  };
+  externalDocs?: {
+    url: string;
+    description?: string;
+  };
+  /** Legacy / codegen. */
+  originalRef?: string;
+}
+interface Properties {
+  [name: string]: Schema;
+}
+//#endregion
+//#region src/body.d.ts
+/** Media Type Object — content for a media type (RequestBody, Response) (OpenAPI 3.x). */
+interface RequestBodyContent {
+  schema?: Schema;
+  itemSchema?: Schema;
+  example?: unknown;
+  examples?: Record<string, AnyObject>;
+  encoding?: Record<string, AnyObject>;
+}
+interface RequestBody {
+  description?: string;
+  /** **REQUIRED**. Media type or range → Media Type or Reference; at least one entry. */
+  content: Record<string, RequestBodyContent | Reference>;
+  required?: boolean;
+}
+//#endregion
+//#region src/parameter.d.ts
+/** collectionFormat for array parameters (Swagger 2.0; OpenAPI 3.x uses style/explode). */
+type CollectionFormat = 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
+/**
+ * Items (Swagger 2.0 only) — used for non-body array parameters and Header when type is array.
+ * Limited subset: no $ref, no file/object; only string, number, integer, boolean, or array (nested).
+ * OpenAPI 3.x uses Schema for parameter items.
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md
+ */
+interface Items {
+  type: 'string' | 'number' | 'integer' | 'boolean' | 'array';
+  format?: string;
+  /** Required when type is "array"; recursive Items. */
+  items?: Items;
+  /** csv, ssv, tsv, pipes (default csv). No "multi" inside Items. */
+  collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes';
+  default?: unknown;
+  maximum?: number;
+  minimum?: number;
+  exclusiveMaximum?: boolean;
+  exclusiveMinimum?: boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  enum?: unknown[];
+  multipleOf?: number;
+}
+/** Parameter style (OpenAPI 3.x). */
+type ParameterStyle = 'matrix' | 'label' | 'simple' | 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject' | 'cookie';
+/**
+ * Parameter — body/formData/path/query/header (Swagger 2.0) or cookie/querystring (OpenAPI 3.x).
+ * Swagger 2.0: when in !== "body" and type === "array", items MUST be Items (see Items), not full Schema.
+ */
+interface Parameter extends Omit<Schema, 'required'> {
+  name: string;
+  /** body/formData = Swagger 2.0; path/query/header/cookie/querystring = OpenAPI 3.x. */
+  in: 'body' | 'header' | 'query' | 'path' | 'formData' | 'cookie' | 'querystring';
+  /** Required when in is not body; one of string, number, integer, boolean, array, file. */
+  type?: Schema['type'] | 'file';
+  description?: string;
+  required?: boolean;
+  /** OpenAPI 3.x: default false. */
+  deprecated?: boolean;
+  /** Required when in is body; Schema Object for the whole body. For OpenAPI 3.x use schema OR content (not both). */
+  schema?: Schema;
+  /** For array: Swagger 2.0 non-body uses Items; body uses Schema. OpenAPI 3.x: Schema. */
+  items?: Schema | Items;
+  /** For array (non-body): csv, ssv, tsv, pipes, multi (query/formData only) — Swagger 2.0. */
+  collectionFormat?: CollectionFormat;
+  /** For query/formData — allows empty value. */
+  allowEmptyValue?: boolean;
+  /** OpenAPI 3.x: serialization style (path default simple; query form; header/cookie simple). */
+  style?: ParameterStyle;
+  /** OpenAPI 3.x: for array/object separate params per value. */
+  explode?: boolean;
+  /** OpenAPI 3.x: reserved expansion (RFC6570). */
+  allowReserved?: boolean;
+  /** OpenAPI 3.x: one media type → representation; required for in: "querystring". */
+  content?: Record<string, unknown>;
+}
+//#endregion
+//#region src/header-link.d.ts
+/**
+ * Header (OpenAPI 3.x) — response/multipart header; follows Parameter (schema or content).
+ * No name/in; style only "simple". Shared by Response.headers and Components.headers.
+ */
+interface Header {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  style?: 'simple';
+  explode?: boolean;
+  schema?: Schema;
+  /** One media type → Media Type or Reference. */
+  content?: Record<string, unknown>;
+  example?: unknown;
+  examples?: Record<string, unknown>;
+}
+/**
+ * Link (OpenAPI 3.x) — design-time link to another operation.
+ * Shared by Response.links and Components.links.
+ */
+interface Link {
+  operationRef?: string;
+  operationId?: string;
+  parameters?: Record<string, unknown>;
+  requestBody?: unknown;
+  description?: string;
+  server?: unknown;
+}
+//#endregion
+//#region src/server.d.ts
+/** Server Object — target host; supports variables in {braces} (OpenAPI 3.x). */
+interface Server {
+  /** **REQUIRED**. Target host URL; query and fragment MUST NOT be used. */
+  url: string;
+  description?: string;
+  /** Optional unique string for the host (OpenAPI 3.1+). */
+  name?: string;
+  variables?: Record<string, ServerVariable>;
+}
+/** Server Variable Object — substitution in server url (OpenAPI 3.x). */
+interface ServerVariable {
+  /** **REQUIRED**. Default for substitution; MUST be in enum if enum is defined. */
+  default: string;
+  /** If present, substitution values from this set. */
+  enum?: string[];
+  description?: string;
+}
+//#endregion
+//#region src/paths.d.ts
+/** Header (Swagger 2.0) — response header. Uses Items for array items, not full Schema. V3 uses schema/content. */
+interface HeaderV2 {
+  description?: string;
+  type: 'string' | 'number' | 'integer' | 'boolean' | 'array';
+  format?: string;
+  /** Required when type is "array"; Items (no $ref/file). */
+  items?: Items;
+  collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes';
+  default?: unknown;
+  maximum?: number;
+  minimum?: number;
+  exclusiveMaximum?: boolean;
+  exclusiveMinimum?: boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  enum?: unknown[];
+  multipleOf?: number;
+}
+/** Headers (Swagger 2.0) — header name to Header. */
+interface HeadersV2 {
+  [name: string]: HeaderV2;
+}
+/** Response (Swagger 2.0) — at least description. */
+interface ResponseV2 {
+  description: string;
+  schema?: Schema;
+  headers?: HeadersV2;
+  /** MIME type to example value. */
+  examples?: Record<string, unknown>;
+}
+/** Response definition or $ref (Swagger 2.0). */
+type ResponseV2Ref = ResponseV2 | Reference;
+/** Responses (Swagger 2.0) — status code or "default" to Response. */
+interface ResponsesV2 {
+  [statusCode: string]: ResponseV2Ref;
+}
+/** Operation (Swagger 2.0). */
+interface OperationV2 {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: {
+    description?: string;
+    url: string;
+  };
+  operationId?: string;
+  consumes?: string[];
+  produces?: string[];
+  parameters?: (Parameter | Reference)[];
+  /** At least one response required. */
+  responses: ResponsesV2;
+  schemes?: ('http' | 'https' | 'ws' | 'wss')[];
+  deprecated?: boolean;
+  security?: SecurityRequirement[];
+}
+/** Path Item (Swagger 2.0) — inline definition; do not mix with $ref. */
+interface PathItemV2 {
+  get?: OperationV2;
+  put?: OperationV2;
+  post?: OperationV2;
+  delete?: OperationV2;
+  options?: OperationV2;
+  head?: OperationV2;
+  patch?: OperationV2;
+  parameters?: (Parameter | Reference)[];
+}
+/** Path Item $ref (Swagger 2.0) — when present, other path fields must not be used. */
+interface PathItemRefV2 {
+  $ref: string;
+}
+/** Path Item or $ref (Swagger 2.0). */
+type PathItemV2Ref = PathItemRefV2 | PathItemV2;
+/** Paths (Swagger 2.0). */
+interface PathsV2 {
+  [path: string]: PathItemV2Ref;
+}
+/** Media Type (OpenAPI 3.x) — content for a media type. */
+interface MediaType {
+  schema?: Schema;
+  /** Sequential media types (e.g. application/jsonl) — per-item schema (OpenAPI 3.1+). */
+  itemSchema?: Schema;
+  example?: unknown;
+  examples?: Record<string, unknown>;
+  encoding?: Record<string, unknown>;
+}
+/** Response (OpenAPI 3.x) — possible response. */
+interface Response {
+  description?: string;
+  summary?: string;
+  /** Header name → Header or Reference (reused from Components). */
+  headers?: Record<string, Header | Reference>;
+  /** Media type or range → Media Type or Reference. */
+  content?: Record<string, MediaType | Reference>;
+  /** Link name → Link or Reference (reused from Components). */
+  links?: Record<string, Link | Reference>;
+}
+/** Response or $ref (OpenAPI 3.x). */
+type ResponseRef = Response | Reference;
+/** Responses (OpenAPI 3.x) — status code or "default" to Response. */
+interface Responses {
+  [status: string]: ResponseRef;
+}
+/** Operation (OpenAPI 3.x) — one API operation. */
+interface Method {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: {
+    url: string;
+    description?: string;
+  };
+  operationId?: string;
+  parameters?: (Parameter | Reference)[];
+  requestBody?: RequestBody | Reference;
+  responses: Responses;
+  /** Runtime expression → Path Item or Reference (Callback). */
+  callbacks?: Record<string, PathItem | Reference>;
+  deprecated?: boolean;
+  security?: Security[];
+  servers?: Server[];
+}
+/** Path Item (OpenAPI 3.x) — operations on a single path. */
+interface PathItem {
+  $ref?: string;
+  summary?: string;
+  description?: string;
+  get?: Method;
+  put?: Method;
+  post?: Method;
+  delete?: Method;
+  options?: Method;
+  head?: Method;
+  patch?: Method;
+  trace?: Method;
+  /** QUERY method (IETF safe-method-w-body) (OpenAPI 3.2). */
+  query?: Method;
+  /** Additional HTTP methods (OpenAPI 3.2). */
+  additionalOperations?: Record<string, Method>;
+  servers?: Server[];
+  parameters?: (Parameter | Reference)[];
+}
+interface Paths {
+  [path: string]: PathItem;
+}
+/** Security Requirement (OpenAPI 3.x) — alias of shared SecurityRequirement. */
+type Security = SecurityRequirement;
+//#endregion
+//#region src/definitions.d.ts
+/** Definition is a Schema Object — reusable type under definitions (Swagger 2.0). */
+type Definition = Schema;
+interface Definitions {
+  [name: string]: Definition;
+}
+/** Parameters Definitions Object — name maps to full Parameter Object; reference elsewhere with #/parameters/name (Spec § Parameters Definitions Object). */
+interface ParametersDefinitions {
+  [name: string]: Parameter;
+}
+/** Responses Definitions (Swagger 2.0) — name maps to full Response; reference elsewhere with #/responses/name. */
+interface ResponsesDefinitions {
+  [name: string]: ResponseV2;
+}
+/** OAuth2 flow (Swagger 2.0 only). OpenAPI 3.x uses OAuth Flows object. */
+type OAuth2Flow = 'implicit' | 'password' | 'application' | 'accessCode';
+/** Scopes — scope name to description (Swagger 2.0 only). */
+interface Scopes {
+  [name: string]: string;
+}
+/** Security scheme (2.0 only): basic. Cannot merge with 3.x (http with scheme "basic" has different structure). */
+interface SecuritySchemeBasicV2 {
+  type: 'basic';
+  description?: string;
+}
+/** Security scheme (2.0 only): apiKey, in query|header. 3.x adds cookie and different optional fields. */
+interface SecuritySchemeApiKeyV2 {
+  type: 'apiKey';
+  name: string;
+  in: 'query' | 'header';
+  description?: string;
+}
+/** Security scheme (2.0 only): oauth2 with flow + authorizationUrl/tokenUrl. 3.x uses OAuth Flows object. */
+interface SecuritySchemeOAuth2V2 {
+  type: 'oauth2';
+  flow: OAuth2Flow;
+  scopes: Scopes;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  description?: string;
+}
+type SecurityDefinitionScheme = SecuritySchemeBasicV2 | SecuritySchemeApiKeyV2 | SecuritySchemeOAuth2V2;
+interface SecurityDefinitions {
+  [name: string]: SecurityDefinitionScheme;
+}
+//#endregion
+//#region src/components.d.ts
+/** Components (OpenAPI 3.x) — reusable objects. At least one of components, paths, or webhooks MUST be present at root. */
+interface Components {
+  schemas?: Definitions;
+  responses?: Record<string, ResponseRef>;
+  parameters?: Record<string, Parameter | Reference>;
+  examples?: Record<string, Example | Reference>;
+  requestBodies?: Record<string, RequestBody | Reference>;
+  headers?: Record<string, Header | Reference>;
+  securitySchemes?: Record<string, SecurityScheme | Reference>;
+  links?: Record<string, Link | Reference>;
+  callbacks?: Record<string, Callback | Reference>;
+  pathItems?: Record<string, PathItem | Reference>;
+  mediaTypes?: Record<string, MediaType | Reference>;
+}
+/** Request Body or $ref (OpenAPI 3.x). */
+interface RequestBodies {
+  [name: string]: RequestBody | Reference;
+}
+/** Example (OpenAPI 3.x) — summary, description, value/dataValue/serializedValue/externalValue. */
+interface Example {
+  summary?: string;
+  description?: string;
+  value?: unknown;
+  dataValue?: unknown;
+  serializedValue?: string;
+  externalValue?: string;
+}
+/** Callback (OpenAPI 3.x) — runtime expression to Path Item. */
+interface Callback {
+  [expression: string]: PathItem;
+}
+interface SecuritySchemes {
+  [name: string]: SecurityScheme | Reference;
+}
+/** apiKey — name and in required. */
+interface ApiKeySecurityScheme {
+  type: 'apiKey';
+  name: string;
+  in: 'query' | 'header' | 'cookie';
+  description?: string;
+  deprecated?: boolean;
+}
+/** http — scheme required (e.g. basic, bearer); bearerFormat for bearer. */
+interface HttpSecurityScheme {
+  type: 'http';
+  scheme: string;
+  bearerFormat?: string;
+  description?: string;
+  deprecated?: boolean;
+}
+/** mutualTLS — client certificate (OpenAPI 3.1+). */
+interface MutualTlsSecurityScheme {
+  type: 'mutualTLS';
+  description?: string;
+  deprecated?: boolean;
+}
+/** OAuth Flow Object — URLs and scopes per flow (OpenAPI 3.x). */
+interface OAuthFlow {
+  authorizationUrl?: string;
+  deviceAuthorizationUrl?: string;
+  tokenUrl?: string;
+  refreshUrl?: string;
+  scopes: StringObject;
+}
+/** OAuth Flows Object — implicit, password, clientCredentials, authorizationCode, deviceAuthorization (OpenAPI 3.2). */
+interface OAuthFlows {
+  implicit?: OAuthFlow;
+  password?: OAuthFlow;
+  clientCredentials?: OAuthFlow;
+  authorizationCode?: OAuthFlow;
+  deviceAuthorization?: OAuthFlow;
+}
+/** oauth2 — flows required. */
+interface OAuth2SecurityScheme {
+  type: 'oauth2';
+  flows: OAuthFlows;
+  oauth2MetadataUrl?: string;
+  description?: string;
+  deprecated?: boolean;
+}
+/** openIdConnect — openIdConnectUrl required. */
+interface OpenIdConnectSecurityScheme {
+  type: 'openIdConnect';
+  openIdConnectUrl: string;
+  description?: string;
+  deprecated?: boolean;
+}
+type SecurityScheme = ApiKeySecurityScheme | HttpSecurityScheme | MutualTlsSecurityScheme | OAuth2SecurityScheme | OpenIdConnectSecurityScheme;
+//#endregion
+//#region src/tag.d.ts
+/** External Documentation Object — url required when present (Swagger 2.0 / OpenAPI 3). */
+interface ExternalDocs {
+  url: string;
+  description?: string;
+}
+/** Tag Object — metadata for tag used by Operation (OpenAPI 3.x). */
+interface Tag {
+  /** **REQUIRED**. Tag name; use in Operation's tags array. */
+  name: string;
+  /** Short summary for display (OpenAPI 3.1+). */
+  summary?: string;
+  description?: string;
+  externalDocs?: ExternalDocs;
+  /** name of a tag this tag is nested under (OpenAPI 3.1+). */
+  parent?: string;
+  /** Machine-readable category e.g. nav, badge, audience (OpenAPI 3.1+). */
+  kind?: string;
+}
+//#endregion
+//#region src/v2.d.ts
+/** Swagger 2.0 root document. Metadata (info, tags, externalDocs, security) uses shared types with OpenAPI 3.x. */
+interface OpenAPISpecificationV2 extends AnyObject {
+  /** MUST be "2.0". */
+  swagger: '2.0';
+  /** API metadata; required. Shared with OpenAPI 3.x (summary/identifier ignored in 2.0). */
+  info: Info;
+  /** Available paths and operations; required. */
+  paths: PathsV2;
+  /** Host only (no scheme/path); MAY include port. */
+  host?: string;
+  /** Path relative to host; MUST start with /. */
+  basePath?: string;
+  /** "http" | "https" | "ws" | "wss". */
+  schemes?: ('http' | 'https' | 'ws' | 'wss')[];
+  /** Global MIME types consumed; overridable per operation. */
+  consumes?: string[];
+  /** Global MIME types produced; overridable per operation. */
+  produces?: string[];
+  /** Reusable data types (Schema). */
+  definitions?: Definitions;
+  /** Reusable parameters; reference with #/parameters/name. */
+  parameters?: ParametersDefinitions;
+  /** Reusable responses; reference with #/responses/name. */
+  responses?: ResponsesDefinitions;
+  /** Security scheme definitions (2.0-only structure). */
+  securityDefinitions?: SecurityDefinitions;
+  /** API-wide security (OR between entries). Shared type with OpenAPI 3.x. */
+  security?: SecurityRequirement[];
+  /** Tag list with metadata. Shared with OpenAPI 3.x (summary/parent/kind ignored in 2.0). */
+  tags?: Tag[];
+  /** Additional documentation. Shared with OpenAPI 3.x. */
+  externalDocs?: ExternalDocs;
+}
+//#endregion
+//#region src/v3.d.ts
+interface OpenAPISpecificationV3 extends AnyObject {
+  /** OAS version (e.g. "3.0.0", "3.2.0"). */
+  openapi: string;
+  /** **REQUIRED**. API metadata. */
+  info: Info;
+  /** Base URI for this document (OpenAPI 3.1+). */
+  $self?: string;
+  /** Default $schema for Schema Objects (OpenAPI 3.1+). */
+  jsonSchemaDialect?: string;
+  /** Connectivity info; default one Server with url: / if absent. */
+  servers?: Server[];
+  /** Available paths and operations. At least one of paths, webhooks, or components MUST be present. */
+  paths?: Paths;
+  /** Incoming webhooks the consumer MAY implement; key = unique name, value = Path Item (OpenAPI 3.1+). */
+  webhooks?: Paths;
+  /** Reusable objects (schemas, parameters, responses, etc.). */
+  components?: Components;
+  /** API-wide security; OR between entries; operations can override. */
+  security?: SecurityRequirement[];
+  /** Tags with metadata. */
+  tags?: Tag[];
+  /** Additional external documentation. */
+  externalDocs?: ExternalDocs;
+}
+//#endregion
+export { AnyObject, ApiKeySecurityScheme, Callback, CollectionFormat, Components, type Contact, Definition, Definitions, Example, ExternalDocs, type Header, HeaderV2, HeadersV2, HttpSecurityScheme, type Info, Items, type License, type Link, type MediaType, Method, MutualTlsSecurityScheme, OAuth2Flow, OAuth2SecurityScheme, OAuthFlow, OAuthFlows, OpenAPISpecificationV2, OpenAPISpecificationV3, OpenIdConnectSecurityScheme, OperationV2, Parameter, ParameterStyle, ParametersDefinitions, PathItem, PathItemRefV2, PathItemV2, PathItemV2Ref, Paths, PathsV2, Properties, Reference, RequestBodies, RequestBody, RequestBodyContent, Response, ResponseRef, ResponseV2, ResponseV2Ref, Responses, ResponsesDefinitions, ResponsesV2, Schema, SchemaType, Scopes, Security, SecurityDefinitionScheme, SecurityDefinitions, type SecurityRequirement, SecurityScheme, SecuritySchemeApiKeyV2, SecuritySchemeBasicV2, SecuritySchemeOAuth2V2, SecuritySchemes, Server, ServerVariable, StringObject, Tag };

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/package.json

@@ -1,12 +1,55 @@
-{
-  "name": "openapi-specification-types",
-  "version": "0.0.4",
-  "types": "./index.d.ts",
-  "main": "index.js",
-  "keywords": [
-    "openapi",
-    "types"
-  ],
-  "author": "",
-  "license": "ISC"
-}
+{
+  "name": "openapi-specification-types",
+  "type": "module",
+  "version": "0.3.0",
+  "description": "TypeScript types for OpenAPI 2.0 and 3.x specifications",
+  "author": "hairyf",
+  "license": "ISC",
+  "homepage": "https://github.com/hairyf/openapi-specification-types#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hairyf/openapi-specification-types.git"
+  },
+  "bugs": "https://github.com/hairyf/openapi-specification-types/issues",
+  "keywords": [
+    "openapi",
+    "types",
+    "swagger"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@antfu/eslint-config": "^7.0.0",
+    "bumpp": "^10.0.0",
+    "eslint": "^9.0.0",
+    "lint-staged": "^15.0.0",
+    "publint": "^0.3.17",
+    "simple-git-hooks": "^2.13.0",
+    "skills": "^1.2.3",
+    "skills-manifest": "^0.2.1",
+    "tsdown": "^0.20.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0",
+    "vitest-package-exports": "^1.0.0"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc",
+    "test": "vitest --typecheck",
+    "lint": "eslint .",
+    "release": "bumpp"
+  }
+}

package/body.d.ts

@@ -1,15 +0,0 @@
-import { AnyObject } from "./common"
-import { Schema } from "./schema"
-
-export interface RequestBody {
-  description?: string
-  content: {
-    [type: string]: {
-      schema: Schema
-      example: AnyObject
-      examples: Record<string, AnyObject>
-      encoding: Record<string, AnyObject>
-    }
-  }
-  required?: boolean
-}

package/common.d.ts

@@ -1,3 +0,0 @@
-export type StringObject = { [key: string]: string }
-export type AnyObject = { [key: string]: any }
-

package/components.d.ts

@@ -1,39 +0,0 @@
-import { RequestBody } from './body'
-import { StringObject } from './common'
-import { Definitions } from './definitions'
-
-export interface Components {
-  schemas: Definitions
-  requestBodies: RequestBodies
-}
-
-export interface RequestBodies {
-  [name: string]: RequestBody
-}
-
-export interface SecuritySchemes {
-  [name: string]: SecurityScheme
-}
-
-export interface SecurityScheme {
-  type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect'
-  description: string
-  name: string
-  in: 'query' | 'header' | 'cookie'
-  scheme: string
-  bearerFormat: string
-  flows: {
-    implicit: OAuthFlow
-    password: OAuthFlow
-    clientCredentials: OAuthFlow
-    authorizationCode: OAuthFlow
-  }
-  openIdConnectUrl: string
-}
-
-export interface OAuthFlow {
-  authorizationUrl: string
-  tokenUrl: string
-  refreshUrl: string
-  scopes: StringObject
-}

package/definitions.d.ts

@@ -1,28 +0,0 @@
-import { Properties, Schema } from './schema'
-
-export interface Definition {
-  type: Schema['type']
-  properties: Properties
-  required: string[]
-}
-
-export interface Definitions {
-  [name: string]: Definition
-}
-
-export interface SecurityDefinitions {
-  api_key: {
-    type: string
-    name: string
-    in: string
-  }
-  petstore_auth: {
-    type: string
-    authorizationUrl: string
-    flow: string
-    scopes: {
-      'read:pets': string
-      'write:pets': string
-    }
-  }
-}

package/index-v2.d.ts

@@ -1,30 +0,0 @@
-import { AnyObject } from './common'
-import { Tag } from './tag'
-import { Paths } from './paths'
-import { Definitions, SecurityDefinitions } from './definitions'
-
-export interface OpenAPISpecificationV2 extends AnyObject {
-  swagger: string
-  host: string
-  basePath: string
-  schemes: string[]
-  consumes: string[]
-  info: {
-    description: string
-    version: string
-    title: string
-    termsOfService: string
-    contact: Record<'name' | 'url' | 'email', string>
-    license: Record<'name' | 'url', string>
-  }
-
-  paths: Paths
-  definitions: Definitions
-
-  securityDefinitions: SecurityDefinitions
-  tags: Tag[]
-  externalDocs: {
-    description: string
-    url: string
-  }
-}

package/index-v3.d.ts

@@ -1,25 +0,0 @@
-import { AnyObject } from './common'
-import { Server } from './server'
-import { Tag } from './tag'
-import { Paths } from './paths'
-import { Components } from './components'
-
-export interface OpenAPISpecificationV3 extends AnyObject {
-  openapi: string
-  info: {
-    description: string
-    version: string
-    title: string
-    termsOfService: string
-    contact: Record<'name' | 'url' | 'email', string>
-    license: Record<'name' | 'url', string>
-  }
-  externalDocs: {
-    description: string
-    url: string
-  }
-  servers: Server[]
-  tags: Tag[]
-  paths: Paths
-  components: Components
-}

package/index.d.ts

@@ -1,11 +0,0 @@
-export * from './index-v2'
-export * from './index-v2'
-
-export * from './components'
-export * from './definitions'
-export * from './parameter'
-export * from './paths'
-export * from './schema'
-export * from './server'
-export * from './tag'
-export * from './body'

package/parameter.d.ts

@@ -1,10 +0,0 @@
-import { Schema } from './schema'
-
-export interface Parameter extends Schema {
-  name: string
-  in: 'body' | 'header' | 'query' | 'path' | 'formData'
-  type?: Schema['type']
-  description?: string
-  required?: boolean
-  schema?: Schema
-}

package/paths.d.ts

@@ -1,40 +0,0 @@
-import { RequestBody } from './body'
-import { Parameter } from './parameter'
-import { Schema, Properties } from './schema'
-
-export interface Paths {
-  [path: string]: {
-    get: Method
-    put: Method
-    post: Method
-    delete: Method
-    options: Method
-    head: Method
-    patch: Method
-    parameters: Parameter[]
-  }
-}
-
-export interface Method {
-  tags: string[]
-  summary: string
-  description: string
-  operationId: string
-  consumes: string[]
-  produces: string[]
-  parameters: Parameter[]
-  responses: Responses
-  security: Security[]
-  requestBody?: RequestBody
-}
-
-export interface Responses {
-  [status: number]: {
-    [type: string]: RequestBody
-  }
-}
-
-export interface Security {
-  petstore_auth: string[]
-  api_key: string[]
-}

package/schema.d.ts

@@ -1,28 +0,0 @@
-type SchemaNumberType = 'integer' | 'long' | 'float' | 'byte' | 'TypesLong' | 'TypesString' | 'string'
-type SchemaStringType = 'byte' | 'binary' | 'date' | 'dateTime' | 'password'
-type SchemaBooleanType = 'boolean'
-type SchemaObjectType = 'object'
-type SchemaArrayType = 'array'
-
-type SchemaType = SchemaNumberType | SchemaStringType | SchemaBooleanType | SchemaObjectType | SchemaArrayType
-
-export interface Schema {
-  type?: SchemaType | SchemaType[]
-  items?: Schema
-  additionalProperties?: Schema
-  originalRef?: string
-  $ref?: string
-  required?: boolean
-  format?: string
-  description?: string
-  schema?: Schema
-  properties?: Properties
-  xml?: { wrapped?: boolean }
-  enum?: string[]
-  allOf?: Schema[]
-  example?: string
-}
-
-export interface Properties {
-  [name: string]: Schema
-}

package/server.d.ts

@@ -1,11 +0,0 @@
-export interface Server {
-  url: string
-  description: string
-  variables: Record<string, Variable>
-}
-
-export interface Variable {
-  enum: string[]
-  default: string
-  description: string
-}

package/tag.d.ts

@@ -1,5 +0,0 @@
-export interface Tag {
-  name: string
-  description: string
-  externalDocs?: { description: string; url: string }
-}