@shipworthy/openapi-parser 0.0.0-stage → 0.0.2

package/dist/schemas/3.1/document.js

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+import { OpenApiComponents } from "./components.js";
+import { OpenApiExternalDocs } from "./external-docs.js";
+import { OpenApiInfo } from "./info.js";
+import { openApiObject } from "./object.js";
+import { OpenApiPathItem } from "./path-item.js";
+import { OpenApiPaths } from "./paths.js";
+import { OpenApiSchema } from "./schema.js";
+import { OpenApiSecurityRequirement } from "./security-requirement.js";
+import { OpenApiServer } from "./server.js";
+import { OpenApiTag } from "./tag.js";
+/** The OpenAPI 3.1 document produced after bundling and upgrading. */
+export const ParsedOpenApi = openApiObject({
+    openapi: Schema.String.check(Schema.isPattern(/^3\.1\.\d+(?:[-+].*)?$/)),
+    info: OpenApiInfo,
+    jsonSchemaDialect: Schema.optionalKey(Schema.String),
+    servers: Schema.optionalKey(Schema.Array(OpenApiServer)),
+    paths: Schema.optionalKey(OpenApiPaths),
+    webhooks: Schema.optionalKey(Schema.Record(Schema.String, OpenApiPathItem)),
+    components: Schema.optionalKey(OpenApiComponents),
+    security: Schema.optionalKey(Schema.Array(OpenApiSecurityRequirement)),
+    tags: Schema.optionalKey(Schema.Array(OpenApiTag)),
+    externalDocs: Schema.optionalKey(OpenApiExternalDocs),
+    $defs: Schema.optionalKey(Schema.Record(Schema.String, OpenApiSchema)),
+});

package/dist/schemas/3.1/encoding.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+import { OpenApiHeader } from "./header.ts";
+export declare const OpenApiEncoding: Schema.StructWithRest<Schema.Struct<{
+    readonly contentType: Schema.optionalKey<Schema.String>;
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly $ref: Schema.String;
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.suspend<Schema.Codec<OpenApiHeader, OpenApiHeader, never, never>>]>>>;
+    readonly style: Schema.optionalKey<Schema.Literals<readonly ["form", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+    readonly explode: Schema.optionalKey<Schema.Boolean>;
+    readonly allowReserved: Schema.optionalKey<Schema.Boolean>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiEncoding = typeof OpenApiEncoding.Type;

package/dist/schemas/3.1/encoding.js

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+import { OpenApiHeader } from "./header.js";
+import { openApiObject } from "./object.js";
+import { withReference } from "./reference.js";
+export const OpenApiEncoding = openApiObject({
+    contentType: Schema.optionalKey(Schema.String),
+    headers: Schema.optionalKey(Schema.Record(Schema.String, withReference(Schema.suspend(() => OpenApiHeader)))),
+    style: Schema.optionalKey(Schema.Literals(["form", "spaceDelimited", "pipeDelimited", "deepObject"])),
+    explode: Schema.optionalKey(Schema.Boolean),
+    allowReserved: Schema.optionalKey(Schema.Boolean),
+});

package/dist/schemas/3.1/example.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+export declare const OpenApiExample: Schema.StructWithRest<Schema.Struct<{
+    readonly summary: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly value: Schema.optionalKey<Schema.Unknown>;
+    readonly externalValue: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiExample = typeof OpenApiExample.Type;

package/dist/schemas/3.1/example.js

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+export const OpenApiExample = openApiObject({
+    summary: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+    value: Schema.optionalKey(Schema.Unknown),
+    externalValue: Schema.optionalKey(Schema.String),
+}).check(Schema.makeFilter((value) => Object.hasOwn(value, "value") && value.externalValue !== undefined
+    ? "Example value and externalValue are mutually exclusive"
+    : undefined));

package/dist/schemas/3.1/external-docs.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+export declare const OpenApiExternalDocs: Schema.StructWithRest<Schema.Struct<{
+    readonly url: Schema.String;
+    readonly description: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiExternalDocs = typeof OpenApiExternalDocs.Type;

package/dist/schemas/3.1/external-docs.js

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+export const OpenApiExternalDocs = openApiObject({
+    url: Schema.String,
+    description: Schema.optionalKey(Schema.String),
+});

package/dist/schemas/3.1/header.d.ts

@@ -0,0 +1,194 @@
+import { Schema } from "effect";
+declare const fields: {
+    description: Schema.optionalKey<Schema.String>;
+    required: Schema.optionalKey<Schema.Boolean>;
+    deprecated: Schema.optionalKey<Schema.Boolean>;
+    style: Schema.optionalKey<Schema.Literal<"simple">>;
+    explode: Schema.optionalKey<Schema.Boolean>;
+    schema: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Unknown>, Schema.Boolean]>>;
+    content: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<{
+        readonly [x: string]: unknown;
+        readonly schema?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly example?: unknown;
+        readonly examples?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly $ref: string;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly [x: string]: unknown;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+                readonly value?: unknown;
+                readonly externalValue?: string | undefined;
+            };
+        } | undefined;
+        readonly encoding?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly contentType?: string | undefined;
+                readonly headers?: {
+                    readonly [x: string]: OpenApiHeader | {
+                        readonly [x: string]: unknown;
+                        readonly $ref: string;
+                        readonly summary?: string | undefined;
+                        readonly description?: string | undefined;
+                    };
+                } | undefined;
+                readonly style?: "deepObject" | "form" | "pipeDelimited" | "spaceDelimited" | undefined;
+                readonly explode?: boolean | undefined;
+                readonly allowReserved?: boolean | undefined;
+            };
+        } | undefined;
+    }, {
+        readonly [x: string]: unknown;
+        readonly schema?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly example?: unknown;
+        readonly examples?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly $ref: string;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly [x: string]: unknown;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+                readonly value?: unknown;
+                readonly externalValue?: string | undefined;
+            };
+        } | undefined;
+        readonly encoding?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly contentType?: string | undefined;
+                readonly headers?: {
+                    readonly [x: string]: OpenApiHeader | {
+                        readonly [x: string]: unknown;
+                        readonly $ref: string;
+                        readonly summary?: string | undefined;
+                        readonly description?: string | undefined;
+                    };
+                } | undefined;
+                readonly style?: "deepObject" | "form" | "pipeDelimited" | "spaceDelimited" | undefined;
+                readonly explode?: boolean | undefined;
+                readonly allowReserved?: boolean | undefined;
+            };
+        } | undefined;
+    }, never, never>>>>;
+    example: Schema.optionalKey<Schema.Unknown>;
+    examples: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly $ref: Schema.String;
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly value: Schema.optionalKey<Schema.Unknown>;
+        readonly externalValue: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>>>;
+};
+/** The interface only ties the recursive knot; every field is inferred from its schema. */
+export interface OpenApiHeader extends Schema.Struct.Type<typeof fields> {
+    readonly [key: string]: unknown;
+}
+export declare const OpenApiHeader: Schema.StructWithRest<Schema.Struct<{
+    description: Schema.optionalKey<Schema.String>;
+    required: Schema.optionalKey<Schema.Boolean>;
+    deprecated: Schema.optionalKey<Schema.Boolean>;
+    style: Schema.optionalKey<Schema.Literal<"simple">>;
+    explode: Schema.optionalKey<Schema.Boolean>;
+    schema: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Unknown>, Schema.Boolean]>>;
+    content: Schema.optionalKey<Schema.$Record<Schema.String, Schema.suspend<Schema.Codec<{
+        readonly [x: string]: unknown;
+        readonly schema?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly example?: unknown;
+        readonly examples?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly $ref: string;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly [x: string]: unknown;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+                readonly value?: unknown;
+                readonly externalValue?: string | undefined;
+            };
+        } | undefined;
+        readonly encoding?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly contentType?: string | undefined;
+                readonly headers?: {
+                    readonly [x: string]: OpenApiHeader | {
+                        readonly [x: string]: unknown;
+                        readonly $ref: string;
+                        readonly summary?: string | undefined;
+                        readonly description?: string | undefined;
+                    };
+                } | undefined;
+                readonly style?: "deepObject" | "form" | "pipeDelimited" | "spaceDelimited" | undefined;
+                readonly explode?: boolean | undefined;
+                readonly allowReserved?: boolean | undefined;
+            };
+        } | undefined;
+    }, {
+        readonly [x: string]: unknown;
+        readonly schema?: boolean | {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly example?: unknown;
+        readonly examples?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly $ref: string;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+            } | {
+                readonly [x: string]: unknown;
+                readonly summary?: string | undefined;
+                readonly description?: string | undefined;
+                readonly value?: unknown;
+                readonly externalValue?: string | undefined;
+            };
+        } | undefined;
+        readonly encoding?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+                readonly contentType?: string | undefined;
+                readonly headers?: {
+                    readonly [x: string]: OpenApiHeader | {
+                        readonly [x: string]: unknown;
+                        readonly $ref: string;
+                        readonly summary?: string | undefined;
+                        readonly description?: string | undefined;
+                    };
+                } | undefined;
+                readonly style?: "deepObject" | "form" | "pipeDelimited" | "spaceDelimited" | undefined;
+                readonly explode?: boolean | undefined;
+                readonly allowReserved?: boolean | undefined;
+            };
+        } | undefined;
+    }, never, never>>>>;
+    example: Schema.optionalKey<Schema.Unknown>;
+    examples: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly $ref: Schema.String;
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly value: Schema.optionalKey<Schema.Unknown>;
+        readonly externalValue: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export {};

package/dist/schemas/3.1/header.js

@@ -0,0 +1,29 @@
+import { Schema } from "effect";
+import { OpenApiExample } from "./example.js";
+import { OpenApiMediaType } from "./media-type.js";
+import { openApiObject } from "./object.js";
+import { withReference } from "./reference.js";
+import { OpenApiSchema } from "./schema.js";
+const fields = {
+    description: Schema.optionalKey(Schema.String),
+    required: Schema.optionalKey(Schema.Boolean),
+    deprecated: Schema.optionalKey(Schema.Boolean),
+    style: Schema.optionalKey(Schema.Literal("simple")),
+    explode: Schema.optionalKey(Schema.Boolean),
+    schema: Schema.optionalKey(OpenApiSchema),
+    content: Schema.optionalKey(Schema.Record(Schema.String, Schema.suspend(() => OpenApiMediaType))),
+    example: Schema.optionalKey(Schema.Unknown),
+    examples: Schema.optionalKey(Schema.Record(Schema.String, withReference(OpenApiExample))),
+};
+export const OpenApiHeader = openApiObject(fields).check(Schema.makeFilter((value) => {
+    if ((value.schema === undefined) === (value.content === undefined)) {
+        return "A header must have exactly one of schema or content";
+    }
+    if (value.content !== undefined && Object.keys(value.content).length !== 1) {
+        return "Header content must contain exactly one media type";
+    }
+    if (Object.hasOwn(value, "example") && value.examples !== undefined) {
+        return "Header example and examples are mutually exclusive";
+    }
+    return undefined;
+}));

package/dist/schemas/3.1/http-method.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+/** Path item keys that hold operations, in traversal order. */
+export declare const OpenApiHttpMethod: Schema.Literals<readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"]>;
+export type OpenApiHttpMethod = typeof OpenApiHttpMethod.Type;

package/dist/schemas/3.1/http-method.js

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+/** Path item keys that hold operations, in traversal order. */
+export const OpenApiHttpMethod = Schema.Literals([
+    "get",
+    "put",
+    "post",
+    "delete",
+    "options",
+    "head",
+    "patch",
+    "trace",
+]);

package/dist/schemas/3.1/index.d.ts

@@ -0,0 +1,29 @@
+export { OpenApiCallback } from "./callback.ts";
+export { OpenApiComponents } from "./components.ts";
+export { OpenApiContact } from "./contact.ts";
+export { ParsedOpenApi } from "./document.ts";
+export { OpenApiEncoding } from "./encoding.ts";
+export { OpenApiExample } from "./example.ts";
+export { OpenApiExternalDocs } from "./external-docs.ts";
+export { OpenApiHeader } from "./header.ts";
+export { OpenApiHttpMethod } from "./http-method.ts";
+export { OpenApiInfo } from "./info.ts";
+export { OpenApiLicense } from "./license.ts";
+export { OpenApiLink } from "./link.ts";
+export { OpenApiMediaType } from "./media-type.ts";
+export { OpenApiOAuthFlow } from "./oauth-flow.ts";
+export { OpenApiOAuthFlows } from "./oauth-flows.ts";
+export { OpenApiOperation } from "./operation.ts";
+export { OpenApiParameter } from "./parameter.ts";
+export { OpenApiPathItem } from "./path-item.ts";
+export { OpenApiPaths } from "./paths.ts";
+export { OpenApiReference } from "./reference.ts";
+export { OpenApiRequestBody } from "./request-body.ts";
+export { OpenApiResponse } from "./response.ts";
+export { OpenApiResponses } from "./responses.ts";
+export { OpenApiSchema } from "./schema.ts";
+export { OpenApiSecurityRequirement } from "./security-requirement.ts";
+export { OpenApiSecurityScheme } from "./security-scheme.ts";
+export { OpenApiServerVariable } from "./server-variable.ts";
+export { OpenApiServer } from "./server.ts";
+export { OpenApiTag } from "./tag.ts";

package/dist/schemas/3.1/index.js

@@ -0,0 +1,29 @@
+export { OpenApiCallback } from "./callback.js";
+export { OpenApiComponents } from "./components.js";
+export { OpenApiContact } from "./contact.js";
+export { ParsedOpenApi } from "./document.js";
+export { OpenApiEncoding } from "./encoding.js";
+export { OpenApiExample } from "./example.js";
+export { OpenApiExternalDocs } from "./external-docs.js";
+export { OpenApiHeader } from "./header.js";
+export { OpenApiHttpMethod } from "./http-method.js";
+export { OpenApiInfo } from "./info.js";
+export { OpenApiLicense } from "./license.js";
+export { OpenApiLink } from "./link.js";
+export { OpenApiMediaType } from "./media-type.js";
+export { OpenApiOAuthFlow } from "./oauth-flow.js";
+export { OpenApiOAuthFlows } from "./oauth-flows.js";
+export { OpenApiOperation } from "./operation.js";
+export { OpenApiParameter } from "./parameter.js";
+export { OpenApiPathItem } from "./path-item.js";
+export { OpenApiPaths } from "./paths.js";
+export { OpenApiReference } from "./reference.js";
+export { OpenApiRequestBody } from "./request-body.js";
+export { OpenApiResponse } from "./response.js";
+export { OpenApiResponses } from "./responses.js";
+export { OpenApiSchema } from "./schema.js";
+export { OpenApiSecurityRequirement } from "./security-requirement.js";
+export { OpenApiSecurityScheme } from "./security-scheme.js";
+export { OpenApiServerVariable } from "./server-variable.js";
+export { OpenApiServer } from "./server.js";
+export { OpenApiTag } from "./tag.js";

package/dist/schemas/3.1/info.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "effect";
+export declare const OpenApiInfo: Schema.StructWithRest<Schema.Struct<{
+    readonly title: Schema.String;
+    readonly version: Schema.String;
+    readonly summary: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly termsOfService: Schema.optionalKey<Schema.String>;
+    readonly contact: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly name: Schema.optionalKey<Schema.String>;
+        readonly url: Schema.optionalKey<Schema.String>;
+        readonly email: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    readonly license: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly identifier: Schema.optionalKey<Schema.String>;
+        readonly url: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiInfo = typeof OpenApiInfo.Type;

package/dist/schemas/3.1/info.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+import { OpenApiContact } from "./contact.js";
+import { OpenApiLicense } from "./license.js";
+import { openApiObject } from "./object.js";
+export const OpenApiInfo = openApiObject({
+    title: Schema.String,
+    version: Schema.String,
+    summary: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+    termsOfService: Schema.optionalKey(Schema.String),
+    contact: Schema.optionalKey(OpenApiContact),
+    license: Schema.optionalKey(OpenApiLicense),
+});

package/dist/schemas/3.1/license.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+export declare const OpenApiLicense: Schema.StructWithRest<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly identifier: Schema.optionalKey<Schema.String>;
+    readonly url: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiLicense = typeof OpenApiLicense.Type;

package/dist/schemas/3.1/license.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+export const OpenApiLicense = openApiObject({
+    name: Schema.String,
+    identifier: Schema.optionalKey(Schema.String),
+    url: Schema.optionalKey(Schema.String),
+}).check(Schema.makeFilter((value) => value.identifier !== undefined && value.url !== undefined
+    ? "License identifier and url are mutually exclusive"
+    : undefined));

package/dist/schemas/3.1/link.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+export declare const OpenApiLink: Schema.StructWithRest<Schema.Struct<{
+    readonly operationRef: Schema.optionalKey<Schema.String>;
+    readonly operationId: Schema.optionalKey<Schema.String>;
+    readonly parameters: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly requestBody: Schema.optionalKey<Schema.Unknown>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly server: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly variables: Schema.optionalKey<Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+            readonly default: Schema.String;
+            readonly enum: Schema.optionalKey<Schema.NonEmptyArray<Schema.String>>;
+            readonly description: Schema.optionalKey<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiLink = typeof OpenApiLink.Type;

package/dist/schemas/3.1/link.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+import { OpenApiServer } from "./server.js";
+export const OpenApiLink = openApiObject({
+    operationRef: Schema.optionalKey(Schema.String),
+    operationId: Schema.optionalKey(Schema.String),
+    parameters: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)),
+    requestBody: Schema.optionalKey(Schema.Unknown),
+    description: Schema.optionalKey(Schema.String),
+    server: Schema.optionalKey(OpenApiServer),
+}).check(Schema.makeFilter((value) => value.operationRef !== undefined && value.operationId !== undefined
+    ? "Link operationRef and operationId are mutually exclusive"
+    : undefined));

package/dist/schemas/3.1/media-type.d.ts

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+export declare const OpenApiMediaType: Schema.StructWithRest<Schema.Struct<{
+    readonly schema: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Unknown>, Schema.Boolean]>>;
+    readonly example: Schema.optionalKey<Schema.Unknown>;
+    readonly examples: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+        readonly $ref: Schema.String;
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.StructWithRest<Schema.Struct<{
+        readonly summary: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly value: Schema.optionalKey<Schema.Unknown>;
+        readonly externalValue: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>>>;
+    readonly encoding: Schema.optionalKey<Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+        readonly contentType: Schema.optionalKey<Schema.String>;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+            readonly $ref: Schema.String;
+            readonly summary: Schema.optionalKey<Schema.String>;
+            readonly description: Schema.optionalKey<Schema.String>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.suspend<Schema.Codec<import("./header.ts").OpenApiHeader, import("./header.ts").OpenApiHeader, never, never>>]>>>;
+        readonly style: Schema.optionalKey<Schema.Literals<readonly ["form", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+        readonly explode: Schema.optionalKey<Schema.Boolean>;
+        readonly allowReserved: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiMediaType = typeof OpenApiMediaType.Type;

package/dist/schemas/3.1/media-type.js

@@ -0,0 +1,14 @@
+import { Schema } from "effect";
+import { OpenApiEncoding } from "./encoding.js";
+import { OpenApiExample } from "./example.js";
+import { openApiObject } from "./object.js";
+import { withReference } from "./reference.js";
+import { OpenApiSchema } from "./schema.js";
+export const OpenApiMediaType = openApiObject({
+    schema: Schema.optionalKey(OpenApiSchema),
+    example: Schema.optionalKey(Schema.Unknown),
+    examples: Schema.optionalKey(Schema.Record(Schema.String, withReference(OpenApiExample))),
+    encoding: Schema.optionalKey(Schema.Record(Schema.String, OpenApiEncoding)),
+}).check(Schema.makeFilter((value) => Object.hasOwn(value, "example") && value.examples !== undefined
+    ? "Media type example and examples are mutually exclusive"
+    : undefined));

package/dist/schemas/3.1/oauth-flow.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+export declare const OpenApiOAuthFlow: Schema.StructWithRest<Schema.Struct<{
+    readonly authorizationUrl: Schema.optionalKey<Schema.String>;
+    readonly tokenUrl: Schema.optionalKey<Schema.String>;
+    readonly refreshUrl: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiOAuthFlow = typeof OpenApiOAuthFlow.Type;

package/dist/schemas/3.1/oauth-flow.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+export const OpenApiOAuthFlow = openApiObject({
+    authorizationUrl: Schema.optionalKey(Schema.String),
+    tokenUrl: Schema.optionalKey(Schema.String),
+    refreshUrl: Schema.optionalKey(Schema.String),
+    scopes: Schema.Record(Schema.String, Schema.String),
+});

package/dist/schemas/3.1/oauth-flows.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+export declare const OpenApiOAuthFlows: Schema.StructWithRest<Schema.Struct<{
+    readonly implicit: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly tokenUrl: Schema.optionalKey<Schema.String>;
+        readonly refreshUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+        readonly authorizationUrl: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    readonly password: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly authorizationUrl: Schema.optionalKey<Schema.String>;
+        readonly refreshUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+        readonly tokenUrl: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    readonly clientCredentials: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly authorizationUrl: Schema.optionalKey<Schema.String>;
+        readonly refreshUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+        readonly tokenUrl: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    readonly authorizationCode: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+        readonly refreshUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Record<Schema.String, Schema.String>;
+        readonly authorizationUrl: Schema.String;
+        readonly tokenUrl: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiOAuthFlows = typeof OpenApiOAuthFlows.Type;

package/dist/schemas/3.1/oauth-flows.js

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+import { OpenApiOAuthFlow } from "./oauth-flow.js";
+import { openApiObject } from "./object.js";
+export const OpenApiOAuthFlows = openApiObject({
+    implicit: Schema.optionalKey(openApiObject({ ...OpenApiOAuthFlow.schema.fields, authorizationUrl: Schema.String })),
+    password: Schema.optionalKey(openApiObject({ ...OpenApiOAuthFlow.schema.fields, tokenUrl: Schema.String })),
+    clientCredentials: Schema.optionalKey(openApiObject({ ...OpenApiOAuthFlow.schema.fields, tokenUrl: Schema.String })),
+    authorizationCode: Schema.optionalKey(openApiObject({
+        ...OpenApiOAuthFlow.schema.fields,
+        authorizationUrl: Schema.String,
+        tokenUrl: Schema.String,
+    })),
+});

package/dist/schemas/3.1/object.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+/** Preserve extensions and unrecognized fields while validating every declared field. */
+export declare function openApiObject<const Fields extends Schema.Struct.Fields>(fields: Fields): Schema.StructWithRest<Schema.Struct<Fields>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+/** Patterned objects also allow specification extensions alongside their entries. */
+export declare function openApiMap<K extends Schema.Record.Key, V extends Schema.Constraint>(key: K, value: V): Schema.StructWithRest<Schema.$Record<K, V>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;

package/dist/schemas/3.1/object.js

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+/** Preserve extensions and unrecognized fields while validating every declared field. */
+export function openApiObject(fields) {
+    return Schema.StructWithRest(Schema.Struct(fields), [
+        Schema.Record(Schema.String, Schema.Unknown),
+    ]);
+}
+/** Patterned objects also allow specification extensions alongside their entries. */
+export function openApiMap(key, value) {
+    const isKey = Schema.is(key);
+    return Schema.StructWithRest(Schema.Record(key, value), [
+        Schema.Record(Schema.String, Schema.Unknown),
+    ]).check(Schema.makeFilter((entries) => {
+        const invalid = Object.keys(entries).find((name) => !name.startsWith("x-") && !isKey(name));
+        return invalid === undefined ? undefined : `Unexpected key ${JSON.stringify(invalid)}`;
+    }));
+}