@shipworthy/openapi-parser 0.0.0-stage → 0.0.1

package/dist/schemas/3.1/operation.js

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+import { OpenApiCallback } from "./callback.js";
+import { OpenApiExternalDocs } from "./external-docs.js";
+import { openApiObject } from "./object.js";
+import { OpenApiParameter } from "./parameter.js";
+import { withReference } from "./reference.js";
+import { OpenApiRequestBody } from "./request-body.js";
+import { OpenApiResponses } from "./responses.js";
+import { OpenApiSecurityRequirement } from "./security-requirement.js";
+import { OpenApiServer } from "./server.js";
+const fields = {
+    tags: Schema.optionalKey(Schema.Array(Schema.String)),
+    summary: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+    externalDocs: Schema.optionalKey(OpenApiExternalDocs),
+    operationId: Schema.optionalKey(Schema.String),
+    parameters: Schema.optionalKey(Schema.Array(withReference(OpenApiParameter))),
+    requestBody: Schema.optionalKey(withReference(OpenApiRequestBody)),
+    responses: Schema.optionalKey(OpenApiResponses),
+    callbacks: Schema.optionalKey(Schema.Record(Schema.String, withReference(Schema.suspend(() => OpenApiCallback)))),
+    deprecated: Schema.optionalKey(Schema.Boolean),
+    security: Schema.optionalKey(Schema.Array(OpenApiSecurityRequirement)),
+    servers: Schema.optionalKey(Schema.Array(OpenApiServer)),
+};
+export const OpenApiOperation = openApiObject(fields);

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

@@ -0,0 +1,101 @@
+import { Schema } from "effect";
+import { OpenApiHeader } from "./header.ts";
+export declare const OpenApiParameter: Schema.StructWithRest<Schema.Struct<{
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly required: Schema.optionalKey<Schema.Boolean>;
+    readonly deprecated: Schema.optionalKey<Schema.Boolean>;
+    readonly explode: Schema.optionalKey<Schema.Boolean>;
+    readonly schema: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Unknown>, Schema.Boolean]>>;
+    readonly 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>>>>;
+    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 name: Schema.String;
+    readonly in: Schema.Literals<readonly ["query", "header", "path", "cookie"]>;
+    readonly style: Schema.optionalKey<Schema.Literals<readonly ["matrix", "label", "form", "simple", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+    readonly allowEmptyValue: Schema.optionalKey<Schema.Boolean>;
+    readonly allowReserved: Schema.optionalKey<Schema.Boolean>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiParameter = typeof OpenApiParameter.Type;

package/dist/schemas/3.1/parameter.js

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import { OpenApiHeader } from "./header.js";
+import { openApiObject } from "./object.js";
+export const OpenApiParameter = openApiObject({
+    ...OpenApiHeader.schema.fields,
+    name: Schema.String,
+    in: Schema.Literals(["query", "header", "path", "cookie"]),
+    style: Schema.optionalKey(Schema.Literals([
+        "matrix",
+        "label",
+        "form",
+        "simple",
+        "spaceDelimited",
+        "pipeDelimited",
+        "deepObject",
+    ])),
+    allowEmptyValue: Schema.optionalKey(Schema.Boolean),
+    allowReserved: Schema.optionalKey(Schema.Boolean),
+}).check(Schema.makeFilter((value) => {
+    if (value.in === "path" && value.required !== true) {
+        return "Path parameters must set required to true";
+    }
+    if ((value.schema === undefined) === (value.content === undefined)) {
+        return "A parameter must have exactly one of schema or content";
+    }
+    if (value.content !== undefined && Object.keys(value.content).length !== 1) {
+        return "Parameter content must contain exactly one media type";
+    }
+    if (Object.hasOwn(value, "example") && value.examples !== undefined) {
+        return "Parameter example and examples are mutually exclusive";
+    }
+    return undefined;
+}));

package/dist/schemas/3.1/path-item.d.ts

@@ -0,0 +1,127 @@
+import { Schema } from "effect";
+import { OpenApiOperation } from "./operation.ts";
+export declare const OpenApiPathItem: Schema.StructWithRest<Schema.Struct<{
+    readonly $ref: Schema.optionalKey<Schema.String>;
+    readonly summary: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly get: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly put: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly post: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly delete: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly options: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly head: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly patch: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly trace: Schema.optionalKey<Schema.suspend<Schema.Codec<OpenApiOperation, OpenApiOperation, never, never>>>;
+    readonly servers: Schema.optionalKey<Schema.$Array<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 parameters: Schema.optionalKey<Schema.$Array<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 description: Schema.optionalKey<Schema.String>;
+        readonly required: Schema.optionalKey<Schema.Boolean>;
+        readonly deprecated: Schema.optionalKey<Schema.Boolean>;
+        readonly explode: Schema.optionalKey<Schema.Boolean>;
+        readonly schema: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Unknown>, Schema.Boolean]>>;
+        readonly 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]: import("./header.ts").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]: import("./header.ts").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>>>>;
+        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 name: Schema.String;
+        readonly in: Schema.Literals<readonly ["query", "header", "path", "cookie"]>;
+        readonly style: Schema.optionalKey<Schema.Literals<readonly ["matrix", "label", "form", "simple", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+        readonly allowEmptyValue: 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 OpenApiPathItem = typeof OpenApiPathItem.Type;

package/dist/schemas/3.1/path-item.js

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+import { OpenApiOperation } from "./operation.js";
+import { OpenApiParameter } from "./parameter.js";
+import { withReference } from "./reference.js";
+import { OpenApiServer } from "./server.js";
+const operation = Schema.optionalKey(Schema.suspend(() => OpenApiOperation));
+export const OpenApiPathItem = openApiObject({
+    $ref: Schema.optionalKey(Schema.String),
+    summary: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+    get: operation,
+    put: operation,
+    post: operation,
+    delete: operation,
+    options: operation,
+    head: operation,
+    patch: operation,
+    trace: operation,
+    servers: Schema.optionalKey(Schema.Array(OpenApiServer)),
+    parameters: Schema.optionalKey(Schema.Array(withReference(OpenApiParameter))),
+});

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

@@ -0,0 +1,126 @@
+import { Schema } from "effect";
+export declare const OpenApiPaths: Schema.StructWithRest<Schema.$Record<Schema.String, Schema.StructWithRest<Schema.Struct<{
+    readonly $ref: Schema.optionalKey<Schema.String>;
+    readonly summary: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly get: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly put: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly post: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly delete: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly options: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly head: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly patch: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly trace: Schema.optionalKey<Schema.suspend<Schema.Codec<import("./operation.ts").OpenApiOperation, import("./operation.ts").OpenApiOperation, never, never>>>;
+    readonly servers: Schema.optionalKey<Schema.$Array<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 parameters: Schema.optionalKey<Schema.$Array<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 description: Schema.optionalKey<Schema.String>;
+        readonly required: Schema.optionalKey<Schema.Boolean>;
+        readonly deprecated: Schema.optionalKey<Schema.Boolean>;
+        readonly explode: Schema.optionalKey<Schema.Boolean>;
+        readonly schema: Schema.optionalKey<Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Unknown>, Schema.Boolean]>>;
+        readonly 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 summary?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly value?: unknown;
+                    readonly externalValue?: string | undefined;
+                } | {
+                    readonly [x: string]: unknown;
+                    readonly $ref: string;
+                    readonly summary?: string | undefined;
+                    readonly description?: string | undefined;
+                };
+            } | undefined;
+            readonly encoding?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                    readonly contentType?: string | undefined;
+                    readonly headers?: {
+                        readonly [x: string]: import("./header.ts").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 summary?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly value?: unknown;
+                    readonly externalValue?: string | undefined;
+                } | {
+                    readonly [x: string]: unknown;
+                    readonly $ref: string;
+                    readonly summary?: string | undefined;
+                    readonly description?: string | undefined;
+                };
+            } | undefined;
+            readonly encoding?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                    readonly contentType?: string | undefined;
+                    readonly headers?: {
+                        readonly [x: string]: import("./header.ts").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>>>>;
+        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 name: Schema.String;
+        readonly in: Schema.Literals<readonly ["query", "header", "path", "cookie"]>;
+        readonly style: Schema.optionalKey<Schema.Literals<readonly ["matrix", "label", "form", "simple", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+        readonly allowEmptyValue: Schema.optionalKey<Schema.Boolean>;
+        readonly allowReserved: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiPaths = typeof OpenApiPaths.Type;

package/dist/schemas/3.1/paths.js

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+import { openApiMap } from "./object.js";
+import { OpenApiPathItem } from "./path-item.js";
+export const OpenApiPaths = openApiMap(Schema.String.check(Schema.isPattern(/^\//)), OpenApiPathItem);

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

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const OpenApiReference: 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>]>;
+export type OpenApiReference = typeof OpenApiReference.Type;
+/** Reference Objects are permitted only at the specification's reference positions. */
+export declare function withReference<S extends Schema.Constraint>(schema: S): 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>]>, S]>;

package/dist/schemas/3.1/reference.js

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+import { openApiObject } from "./object.js";
+export const OpenApiReference = openApiObject({
+    $ref: Schema.String,
+    summary: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+});
+/** Reference Objects are permitted only at the specification's reference positions. */
+export function withReference(schema) {
+    return Schema.Union([OpenApiReference, schema]);
+}

package/dist/schemas/3.1/request-body.d.ts

@@ -0,0 +1,31 @@
+import { Schema } from "effect";
+export declare const OpenApiRequestBody: Schema.StructWithRest<Schema.Struct<{
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly content: Schema.$Record<Schema.String, 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>]>>;
+    readonly required: Schema.optionalKey<Schema.Boolean>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type OpenApiRequestBody = typeof OpenApiRequestBody.Type;

package/dist/schemas/3.1/request-body.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+import { OpenApiMediaType } from "./media-type.js";
+import { openApiObject } from "./object.js";
+export const OpenApiRequestBody = openApiObject({
+    description: Schema.optionalKey(Schema.String),
+    content: Schema.Record(Schema.String, OpenApiMediaType),
+    required: Schema.optionalKey(Schema.Boolean),
+});