@rhythmjs/openapi 0.0.1

package/dist/metadata-CT05Tw6j.d.ts

@@ -0,0 +1,62 @@
+import { D as SecurityRequirementObject, E as SchemaObject, S as ReferenceObject, _ as ParameterLocation, a as ExampleObject, d as LinkObject, g as OperationObject, i as EncodingObject, t as CallbackObject, y as ParameterStyle } from "./types-DeDU0OMv.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { Middleware } from "@rhythmjs/rhythm/types";
+import { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+//#region src/metadata/metadata.d.ts
+declare const OPENAPI_METADATA: symbol;
+type SchemaLike = StandardSchemaV1 | SchemaObject;
+interface MediaTypeSpec {
+  schema?: SchemaLike;
+  example?: unknown;
+  examples?: Record<string, ExampleObject | ReferenceObject>;
+  encoding?: Record<string, EncodingObject>;
+}
+interface ParameterOverride {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: ParameterStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+  example?: unknown;
+  examples?: Record<string, ExampleObject | ReferenceObject>;
+}
+interface ParameterGroupSpec {
+  in: ParameterLocation;
+  schema: SchemaLike;
+  overrides?: Record<string, ParameterOverride>;
+}
+interface RequestBodySpec {
+  description?: string;
+  required?: boolean;
+  content: Record<string, MediaTypeSpec>;
+}
+interface HeaderSpec {
+  description?: string;
+  required?: boolean;
+  schema?: SchemaLike;
+}
+interface ResponseSpec {
+  description: string;
+  content?: Record<string, MediaTypeSpec>;
+  headers?: Record<string, HeaderSpec | ReferenceObject>;
+  links?: Record<string, LinkObject | ReferenceObject>;
+}
+type OperationFields = Pick<OperationObject, "summary" | "description" | "operationId" | "deprecated" | "externalDocs" | "servers">;
+interface OperationFragment {
+  operation?: OperationFields;
+  tags?: readonly string[];
+  parameters?: readonly ParameterGroupSpec[];
+  requestBody?: RequestBodySpec;
+  responses?: Record<string, ResponseSpec | ReferenceObject>;
+  security?: readonly SecurityRequirementObject[] | "none";
+  callbacks?: Record<string, CallbackObject | ReferenceObject>;
+  extensions?: Record<`x-${string}`, unknown>;
+  exclude?: boolean;
+}
+declare function withFragment<TFn>(fn: TFn, fragment: OperationFragment): TFn;
+declare function fragmentOf(fn: unknown): OperationFragment | undefined;
+declare function docOnly(fragment: OperationFragment): Middleware<RhythmHttpContext>;
+//#endregion
+export { OperationFragment as a, RequestBodySpec as c, docOnly as d, fragmentOf as f, OperationFields as i, ResponseSpec as l, MediaTypeSpec as n, ParameterGroupSpec as o, withFragment as p, OPENAPI_METADATA as r, ParameterOverride as s, HeaderSpec as t, SchemaLike as u };

package/dist/operation/operation.d.ts

@@ -0,0 +1,7 @@
+import { i as OperationFields } from "../metadata-CT05Tw6j.js";
+import { Middleware } from "@rhythmjs/rhythm/types";
+import { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+//#region src/operation/operation.d.ts
+export type ApiOperationOptions = OperationFields;
+export declare function apiOperation(options: ApiOperationOptions): Middleware<RhythmHttpContext>;
+//#endregion

package/dist/operation/operation.js

@@ -0,0 +1,7 @@
+import { docOnly } from "../metadata/metadata.js";
+//#region src/operation/operation.ts
+function apiOperation(options) {
+	return docOnly({ operation: options });
+}
+//#endregion
+export { apiOperation };

package/dist/param/param.d.ts

@@ -0,0 +1,10 @@
+import { s as ParameterOverride } from "../metadata-CT05Tw6j.js";
+import { n as ValidationContext, t as Validated } from "../runtime-CtmUGPnb.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { DeriveMiddleware } from "@rhythmjs/rhythm/types";
+//#region src/param/param.d.ts
+export interface ApiParamOptions {
+  overrides?: Record<string, ParameterOverride>;
+}
+export declare function apiParam<TSchema extends StandardSchemaV1>(schema: TSchema, options?: ApiParamOptions): DeriveMiddleware<ValidationContext, Validated<"param", TSchema>>;
+//#endregion

package/dist/param/param.js

@@ -0,0 +1,14 @@
+import { a as schemaMiddleware } from "../runtime-CCU9lE2d.js";
+//#region src/param/param.ts
+function apiParam(schema, options = {}) {
+	return schemaMiddleware("param", schema, { parameters: [{
+		in: "path",
+		schema,
+		...options.overrides ? { overrides: options.overrides } : {}
+	}] }, (ctx) => ({
+		ok: true,
+		value: ctx.params ?? {}
+	}));
+}
+//#endregion
+export { apiParam };

package/dist/query/query.d.ts

@@ -0,0 +1,10 @@
+import { s as ParameterOverride } from "../metadata-CT05Tw6j.js";
+import { n as ValidationContext, t as Validated } from "../runtime-CtmUGPnb.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { DeriveMiddleware } from "@rhythmjs/rhythm/types";
+//#region src/query/query.d.ts
+export interface ApiQueryOptions {
+  overrides?: Record<string, ParameterOverride>;
+}
+export declare function apiQuery<TSchema extends StandardSchemaV1>(schema: TSchema, options?: ApiQueryOptions): DeriveMiddleware<ValidationContext, Validated<"query", TSchema>>;
+//#endregion

package/dist/query/query.js

@@ -0,0 +1,14 @@
+import { a as schemaMiddleware, i as collectQuery } from "../runtime-CCU9lE2d.js";
+//#region src/query/query.ts
+function apiQuery(schema, options = {}) {
+	return schemaMiddleware("query", schema, { parameters: [{
+		in: "query",
+		schema,
+		...options.overrides ? { overrides: options.overrides } : {}
+	}] }, (ctx) => ({
+		ok: true,
+		value: collectQuery(ctx.request.url)
+	}));
+}
+//#endregion
+export { apiQuery };

package/dist/resolver/resolver.d.ts

@@ -0,0 +1,2 @@
+import { a as resolveSchema, i as isStandardSchema, n as SchemaConverter, r as SchemaIO, t as ResolverOptions } from "../resolver-sb66uMQ-.js";
+export { ResolverOptions, SchemaConverter, SchemaIO, isStandardSchema, resolveSchema };

package/dist/resolver/resolver.js

@@ -0,0 +1,37 @@
+//#region src/resolver/resolver.ts
+function isStandardSchema(value) {
+	return typeof value === "object" && value !== null && "~standard" in value;
+}
+async function convertZod(schema, io) {
+	const { z } = await import("zod");
+	return z.toJSONSchema(schema, {
+		io,
+		target: "draft-2020-12",
+		unrepresentable: "any"
+	});
+}
+async function convertValibot(schema, io) {
+	const { toJsonSchema } = await import("@valibot/to-json-schema");
+	return toJsonSchema(schema, {
+		errorMode: "ignore",
+		typeMode: io
+	});
+}
+const builtinConverters = {
+	zod: convertZod,
+	valibot: convertValibot
+};
+async function resolveSchema(schema, io, options = {}) {
+	if (!isStandardSchema(schema)) return schema;
+	const vendor = schema["~standard"].vendor;
+	const convert = options.converters?.[vendor] ?? builtinConverters[vendor];
+	if (!convert) throw new Error(`No JSON Schema converter for schema vendor "${vendor}". Pass one via the "converters" option.`);
+	const json = await convert(schema, io);
+	if (typeof json === "object" && json !== null && "$schema" in json) {
+		const { $schema: _dialect, ...rest } = json;
+		return rest;
+	}
+	return json;
+}
+//#endregion
+export { isStandardSchema, resolveSchema };

package/dist/resolver-sb66uMQ-.d.ts

@@ -0,0 +1,13 @@
+import { E as SchemaObject } from "./types-DeDU0OMv.js";
+import { u as SchemaLike } from "./metadata-CT05Tw6j.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/resolver/resolver.d.ts
+type SchemaIO = "input" | "output";
+type SchemaConverter = (schema: StandardSchemaV1, io: SchemaIO) => SchemaObject | Promise<SchemaObject>;
+interface ResolverOptions {
+  converters?: Record<string, SchemaConverter>;
+}
+declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+declare function resolveSchema(schema: SchemaLike, io: SchemaIO, options?: ResolverOptions): Promise<SchemaObject>;
+//#endregion
+export { resolveSchema as a, isStandardSchema as i, SchemaConverter as n, SchemaIO as r, ResolverOptions as t };

package/dist/response/response.d.ts

@@ -0,0 +1,18 @@
+import { S as ReferenceObject, a as ExampleObject, d as LinkObject } from "../types-DeDU0OMv.js";
+import { n as MediaTypeSpec, t as HeaderSpec, u as SchemaLike } from "../metadata-CT05Tw6j.js";
+import { Middleware } from "@rhythmjs/rhythm/types";
+import { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+//#region src/response/response.d.ts
+export type ResponseStatus = number | "default" | "1XX" | "2XX" | "3XX" | "4XX" | "5XX";
+export interface ApiResponseOptions {
+  description: string;
+  schema?: SchemaLike;
+  contentType?: string;
+  example?: unknown;
+  examples?: Record<string, ExampleObject | ReferenceObject>;
+  content?: Record<string, MediaTypeSpec>;
+  headers?: Record<string, HeaderSpec | ReferenceObject>;
+  links?: Record<string, LinkObject | ReferenceObject>;
+}
+export declare function apiResponse(status: ResponseStatus, options: ApiResponseOptions): Middleware<RhythmHttpContext>;
+//#endregion

package/dist/response/response.js

@@ -0,0 +1,19 @@
+import { docOnly } from "../metadata/metadata.js";
+//#region src/response/response.ts
+function apiResponse(status, options) {
+	const hasShorthand = options.schema !== void 0 || options.example !== void 0 || options.examples;
+	const content = options.content ?? (hasShorthand ? { [options.contentType ?? "application/json"]: {
+		...options.schema !== void 0 ? { schema: options.schema } : {},
+		...options.example !== void 0 ? { example: options.example } : {},
+		...options.examples ? { examples: options.examples } : {}
+	} } : void 0);
+	const spec = {
+		description: options.description,
+		...content ? { content } : {},
+		...options.headers ? { headers: options.headers } : {},
+		...options.links ? { links: options.links } : {}
+	};
+	return docOnly({ responses: { [String(status)]: spec } });
+}
+//#endregion
+export { apiResponse };

package/dist/runtime-CCU9lE2d.js

@@ -0,0 +1,137 @@
+import { withFragment } from "./metadata/metadata.js";
+//#region src/internal/runtime.ts
+function serializeIssues(issues) {
+	return issues.map((issue) => {
+		const path = issue.path?.map((segment) => typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment);
+		return {
+			message: issue.message,
+			...path ? { path: path.filter((key) => typeof key !== "symbol") } : {}
+		};
+	});
+}
+function collectMultiValue(pairs) {
+	const out = {};
+	for (const [key, value] of pairs) {
+		const existing = out[key];
+		if (existing === void 0) out[key] = value;
+		else if (Array.isArray(existing)) existing.push(value);
+		else out[key] = [existing, value];
+	}
+	return out;
+}
+function collectQuery(url) {
+	return collectMultiValue(new URL(url).searchParams);
+}
+function collectHeaders(request) {
+	const out = {};
+	for (const [key, value] of request.headers) out[key] = value;
+	return out;
+}
+function collectCookies(request) {
+	const out = {};
+	const header = request.headers.get("cookie");
+	if (!header) return out;
+	for (const pair of header.split(";")) {
+		const eq = pair.indexOf("=");
+		if (eq === -1) continue;
+		const key = pair.slice(0, eq).trim();
+		if (!key) continue;
+		let value = pair.slice(eq + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+		try {
+			out[key] = decodeURIComponent(value);
+		} catch {
+			out[key] = value;
+		}
+	}
+	return out;
+}
+function parseMultipart(body, contentTypeHeader) {
+	const boundary = /boundary="?([^";]+)"?/i.exec(contentTypeHeader)?.[1];
+	if (!boundary) return void 0;
+	const pairs = [];
+	for (const part of body.split(`--${boundary}`)) {
+		const headerEnd = part.indexOf("\r\n\r\n");
+		if (headerEnd === -1) continue;
+		const headers = part.slice(0, headerEnd);
+		const name = /content-disposition:[^\r\n]*\sname="([^"]*)"/i.exec(headers)?.[1];
+		if (name === void 0) continue;
+		const value = /\sfilename="([^"]*)"/i.exec(headers)?.[1] ?? part.slice(headerEnd + 4).replace(/\r\n$/, "");
+		pairs.push([name, value]);
+	}
+	return collectMultiValue(pairs);
+}
+function bodyExtractor(contentType) {
+	return async (ctx) => {
+		if (contentType.includes("json")) try {
+			return {
+				ok: true,
+				value: await ctx.request.clone().json()
+			};
+		} catch {
+			return {
+				ok: false,
+				message: "Malformed JSON in request body"
+			};
+		}
+		let text;
+		try {
+			text = await ctx.request.clone().text();
+		} catch {
+			return {
+				ok: false,
+				message: "Unreadable request body"
+			};
+		}
+		if (contentType.includes("x-www-form-urlencoded")) return {
+			ok: true,
+			value: collectMultiValue(new URLSearchParams(text))
+		};
+		if (contentType.includes("form-data")) {
+			const value = parseMultipart(text, ctx.request.headers.get("content-type") ?? contentType);
+			return value ? {
+				ok: true,
+				value
+			} : {
+				ok: false,
+				message: "Malformed form data in request body"
+			};
+		}
+		return {
+			ok: true,
+			value: text
+		};
+	};
+}
+function schemaMiddleware(target, schema, fragment, extract) {
+	const middleware = async (ctx, next) => {
+		const fail = (issues) => {
+			const failure = {
+				success: false,
+				target,
+				issues
+			};
+			ctx.response.status = 400;
+			ctx.response.headers.set("content-type", "application/json");
+			ctx.response.body = JSON.stringify(failure);
+		};
+		const extracted = await extract(ctx);
+		if (!extracted.ok) {
+			fail([{ message: extracted.message }]);
+			return;
+		}
+		const result = await schema["~standard"].validate(extracted.value);
+		if (result.issues) {
+			fail(serializeIssues(result.issues));
+			return;
+		}
+		ctx.valid = {
+			...ctx.valid,
+			[target]: result.value
+		};
+		await next();
+	};
+	return withFragment(middleware, fragment);
+}
+//#endregion
+export { schemaMiddleware as a, collectQuery as i, collectCookies as n, collectHeaders as r, bodyExtractor as t };

package/dist/runtime-CtmUGPnb.d.ts

@@ -0,0 +1,24 @@
+import "./metadata-CT05Tw6j.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { DeriveMiddleware } from "@rhythmjs/rhythm/types";
+import { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+import { RhythmRouterContext } from "@rhythmjs/router";
+//#region src/internal/runtime.d.ts
+type ValidationTarget = "body" | "query" | "param" | "header" | "cookie";
+type ValidationContext = RhythmHttpContext & Partial<RhythmRouterContext> & {
+  valid?: Partial<Record<ValidationTarget, unknown>>;
+};
+type Validated<TTarget extends ValidationTarget, TSchema extends StandardSchemaV1> = {
+  valid: { [K in TTarget]: StandardSchemaV1.InferOutput<TSchema>; };
+};
+interface ValidationIssue {
+  message: string;
+  path?: readonly (string | number)[];
+}
+interface ValidationFailure {
+  success: false;
+  target: ValidationTarget;
+  issues: readonly ValidationIssue[];
+}
+//#endregion
+export { ValidationTarget as a, ValidationIssue as i, ValidationContext as n, ValidationFailure as r, Validated as t };

package/dist/security/security.d.ts

@@ -0,0 +1,11 @@
+import { Middleware } from "@rhythmjs/rhythm/types";
+import { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+//#region src/security/security.d.ts
+export declare function apiSecurity(name: string, scopes?: string[]): Middleware<RhythmHttpContext>;
+export declare function apiBearerAuth(name?: string): Middleware<RhythmHttpContext>;
+export declare function apiBasicAuth(name?: string): Middleware<RhythmHttpContext>;
+export declare function apiCookieAuth(name?: string): Middleware<RhythmHttpContext>;
+export declare function apiKeyAuth(name?: string): Middleware<RhythmHttpContext>;
+export declare function apiOAuth2(scopes: string[], name?: string): Middleware<RhythmHttpContext>;
+export declare function apiNoSecurity(): Middleware<RhythmHttpContext>;
+//#endregion

package/dist/security/security.js

@@ -0,0 +1,25 @@
+import { docOnly } from "../metadata/metadata.js";
+//#region src/security/security.ts
+function apiSecurity(name, scopes = []) {
+	return docOnly({ security: [{ [name]: scopes }] });
+}
+function apiBearerAuth(name = "bearer") {
+	return apiSecurity(name);
+}
+function apiBasicAuth(name = "basic") {
+	return apiSecurity(name);
+}
+function apiCookieAuth(name = "cookie") {
+	return apiSecurity(name);
+}
+function apiKeyAuth(name = "api-key") {
+	return apiSecurity(name);
+}
+function apiOAuth2(scopes, name = "oauth2") {
+	return apiSecurity(name, scopes);
+}
+function apiNoSecurity() {
+	return docOnly({ security: "none" });
+}
+//#endregion
+export { apiBasicAuth, apiBearerAuth, apiCookieAuth, apiKeyAuth, apiNoSecurity, apiOAuth2, apiSecurity };

package/dist/tags/tags.d.ts

@@ -0,0 +1,5 @@
+import { Middleware } from "@rhythmjs/rhythm/types";
+import { RhythmHttpContext } from "@rhythmjs/router/adapters/context";
+//#region src/tags/tags.d.ts
+export declare function apiTags(...tags: string[]): Middleware<RhythmHttpContext>;
+//#endregion

package/dist/tags/tags.js

@@ -0,0 +1,7 @@
+import { docOnly } from "../metadata/metadata.js";
+//#region src/tags/tags.ts
+function apiTags(...tags) {
+	return docOnly({ tags });
+}
+//#endregion
+export { apiTags };

package/dist/types/types.d.ts

@@ -0,0 +1,2 @@
+import { A as ServerVariableObject, C as RequestBodyObject, D as SecurityRequirementObject, E as SchemaObject, O as SecuritySchemeObject, S as ReferenceObject, T as ResponsesObject, _ as ParameterLocation, a as ExampleObject, b as PathItemObject, c as HeaderObject, d as LinkObject, f as MediaTypeObject, g as OperationObject, h as OpenAPIObject, i as EncodingObject, j as TagObject, k as ServerObject, l as InfoObject, m as OAuthFlowsObject, n as ComponentsObject, o as Extensible, p as OAuthFlowObject, r as ContactObject, s as ExternalDocsObject, t as CallbackObject, u as LicenseObject, v as ParameterObject, w as ResponseObject, x as PathsObject, y as ParameterStyle } from "../types-DeDU0OMv.js";
+export { CallbackObject, ComponentsObject, ContactObject, EncodingObject, ExampleObject, Extensible, ExternalDocsObject, HeaderObject, InfoObject, LicenseObject, LinkObject, MediaTypeObject, OAuthFlowObject, OAuthFlowsObject, OpenAPIObject, OperationObject, ParameterLocation, ParameterObject, ParameterStyle, PathItemObject, PathsObject, ReferenceObject, RequestBodyObject, ResponseObject, ResponsesObject, SchemaObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject, ServerVariableObject, TagObject };

package/dist/types/types.js

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

package/dist/types-DeDU0OMv.d.ts

@@ -0,0 +1,197 @@
+//#region src/types/types.d.ts
+interface Extensible {
+  [extension: `x-${string}`]: unknown;
+}
+type SchemaObject = Record<string, unknown> | boolean;
+interface ReferenceObject {
+  $ref: string;
+  summary?: string;
+  description?: string;
+}
+interface ContactObject extends Extensible {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+interface LicenseObject extends Extensible {
+  name: string;
+  identifier?: string;
+  url?: string;
+}
+interface InfoObject extends Extensible {
+  title: string;
+  summary?: string;
+  description?: string;
+  termsOfService?: string;
+  contact?: ContactObject;
+  license?: LicenseObject;
+  version: string;
+}
+interface ServerVariableObject extends Extensible {
+  enum?: string[];
+  default: string;
+  description?: string;
+}
+interface ServerObject extends Extensible {
+  url: string;
+  description?: string;
+  variables?: Record<string, ServerVariableObject>;
+}
+interface ExternalDocsObject extends Extensible {
+  description?: string;
+  url: string;
+}
+interface TagObject extends Extensible {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDocsObject;
+}
+interface ExampleObject extends Extensible {
+  summary?: string;
+  description?: string;
+  value?: unknown;
+  externalValue?: string;
+}
+type ParameterLocation = "query" | "header" | "path" | "cookie";
+type ParameterStyle = "matrix" | "label" | "simple" | "form" | "spaceDelimited" | "pipeDelimited" | "deepObject";
+interface ParameterObject extends Extensible {
+  name: string;
+  in: ParameterLocation;
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: ParameterStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: SchemaObject;
+  example?: unknown;
+  examples?: Record<string, ExampleObject | ReferenceObject>;
+  content?: Record<string, MediaTypeObject>;
+}
+type HeaderObject = Omit<ParameterObject, "name" | "in">;
+interface EncodingObject extends Extensible {
+  contentType?: string;
+  headers?: Record<string, HeaderObject | ReferenceObject>;
+  style?: ParameterStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+}
+interface MediaTypeObject extends Extensible {
+  schema?: SchemaObject;
+  example?: unknown;
+  examples?: Record<string, ExampleObject | ReferenceObject>;
+  encoding?: Record<string, EncodingObject>;
+}
+interface RequestBodyObject extends Extensible {
+  description?: string;
+  content: Record<string, MediaTypeObject>;
+  required?: boolean;
+}
+interface LinkObject extends Extensible {
+  operationRef?: string;
+  operationId?: string;
+  parameters?: Record<string, unknown>;
+  requestBody?: unknown;
+  description?: string;
+  server?: ServerObject;
+}
+interface ResponseObject extends Extensible {
+  description: string;
+  headers?: Record<string, HeaderObject | ReferenceObject>;
+  content?: Record<string, MediaTypeObject>;
+  links?: Record<string, LinkObject | ReferenceObject>;
+}
+type ResponsesObject = Record<string, ResponseObject | ReferenceObject>;
+type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
+type SecurityRequirementObject = Record<string, string[]>;
+interface OAuthFlowObject extends Extensible {
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  refreshUrl?: string;
+  scopes: Record<string, string>;
+}
+interface OAuthFlowsObject extends Extensible {
+  implicit?: OAuthFlowObject;
+  password?: OAuthFlowObject;
+  clientCredentials?: OAuthFlowObject;
+  authorizationCode?: OAuthFlowObject;
+}
+type SecuritySchemeObject = (Extensible & {
+  type: "apiKey";
+  description?: string;
+  name: string;
+  in: "query" | "header" | "cookie";
+}) | (Extensible & {
+  type: "http";
+  description?: string;
+  scheme: string;
+  bearerFormat?: string;
+}) | (Extensible & {
+  type: "mutualTLS";
+  description?: string;
+}) | (Extensible & {
+  type: "oauth2";
+  description?: string;
+  flows: OAuthFlowsObject;
+}) | (Extensible & {
+  type: "openIdConnect";
+  description?: string;
+  openIdConnectUrl: string;
+});
+interface OperationObject extends Extensible {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: ExternalDocsObject;
+  operationId?: string;
+  parameters?: (ParameterObject | ReferenceObject)[];
+  requestBody?: RequestBodyObject | ReferenceObject;
+  responses?: ResponsesObject;
+  callbacks?: Record<string, CallbackObject | ReferenceObject>;
+  deprecated?: boolean;
+  security?: SecurityRequirementObject[];
+  servers?: ServerObject[];
+}
+interface PathItemObject extends Extensible {
+  $ref?: string;
+  summary?: string;
+  description?: string;
+  get?: OperationObject;
+  put?: OperationObject;
+  post?: OperationObject;
+  delete?: OperationObject;
+  options?: OperationObject;
+  head?: OperationObject;
+  patch?: OperationObject;
+  trace?: OperationObject;
+  servers?: ServerObject[];
+  parameters?: (ParameterObject | ReferenceObject)[];
+}
+type PathsObject = Record<string, PathItemObject>;
+interface ComponentsObject extends Extensible {
+  schemas?: Record<string, SchemaObject>;
+  responses?: Record<string, ResponseObject | ReferenceObject>;
+  parameters?: Record<string, ParameterObject | ReferenceObject>;
+  examples?: Record<string, ExampleObject | ReferenceObject>;
+  requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+  headers?: Record<string, HeaderObject | ReferenceObject>;
+  securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+  links?: Record<string, LinkObject | ReferenceObject>;
+  callbacks?: Record<string, CallbackObject | ReferenceObject>;
+  pathItems?: Record<string, PathItemObject>;
+}
+interface OpenAPIObject extends Extensible {
+  openapi: string;
+  info: InfoObject;
+  jsonSchemaDialect?: string;
+  servers?: ServerObject[];
+  paths?: PathsObject;
+  webhooks?: Record<string, PathItemObject>;
+  components?: ComponentsObject;
+  security?: SecurityRequirementObject[];
+  tags?: TagObject[];
+  externalDocs?: ExternalDocsObject;
+}
+//#endregion
+export { ServerVariableObject as A, RequestBodyObject as C, SecurityRequirementObject as D, SchemaObject as E, SecuritySchemeObject as O, ReferenceObject as S, ResponsesObject as T, ParameterLocation as _, ExampleObject as a, PathItemObject as b, HeaderObject as c, LinkObject as d, MediaTypeObject as f, OperationObject as g, OpenAPIObject as h, EncodingObject as i, TagObject as j, ServerObject as k, InfoObject as l, OAuthFlowsObject as m, ComponentsObject as n, Extensible as o, OAuthFlowObject as p, ContactObject as r, ExternalDocsObject as s, CallbackObject as t, LicenseObject as u, ParameterObject as v, ResponseObject as w, PathsObject as x, ParameterStyle as y };