@scalar/openapi-types 0.2.1 → 0.2.3

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

@@ -1,62 +1,54 @@
-import { z } from 'zod';
-import { BasePathItemObjectSchema } from './base-path-item-object.js';
-import { OperationObjectSchema } from './operation-object.js';
-
-/**
- * Path Item Object
- *
- * Describes the operations available on a single path. A Path Item MAY be empty, due to ACL constraints. The path
- * itself is still exposed to the documentation viewer but they will not know which operations and parameters are
- * available.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#path-item-object
- */
+import { z } from "zod";
+import { BasePathItemObjectSchema } from "./base-path-item-object.js";
+import { OperationObjectSchema } from "./operation-object.js";
 const PathItemObjectSchema = BasePathItemObjectSchema.extend({
-    /**
-     * Allows for a referenced definition of this path item. The value MUST be in the form of a URI, and the referenced
-     * structure MUST be in the form of a Path Item Object. In case a Path Item Object field appears both in the defined
-     * object and the referenced object, the behavior is undefined. See the rules for resolving Relative References.
-     *
-     * Note: The behavior of $ref with adjacent properties is likely to change in future versions of this specification to
-     * bring it into closer alignment with the behavior of the Reference Object.
-     *
-     * Q: Why don’t we just use `ReferenceObjectSchema`?
-     * A: References work a little bit different here. It’s the only place where they can be combined with other
-     *    properties.
-     */
-    '$ref': z.string().optional(),
-    /**
-     * A definition of a GET operation on this path.
-     */
-    get: OperationObjectSchema.optional(),
-    /**
-     * A definition of a PUT operation on this path.
-     */
-    put: OperationObjectSchema.optional(),
-    /**
-     * A definition of a POST operation on this path.
-     */
-    post: OperationObjectSchema.optional(),
-    /**
-     * A definition of a DELETE operation on this path.
-     */
-    delete: OperationObjectSchema.optional(),
-    /**
-     * A definition of a OPTIONS operation on this path.
-     */
-    options: OperationObjectSchema.optional(),
-    /**
-     * A definition of a HEAD operation on this path.
-     */
-    head: OperationObjectSchema.optional(),
-    /**
-     * A definition of a PATCH operation on this path.
-     */
-    patch: OperationObjectSchema.optional(),
-    /**
-     * A definition of a TRACE operation on this path.
-     */
-    trace: OperationObjectSchema.optional(),
+  /**
+   * Allows for a referenced definition of this path item. The value MUST be in the form of a URI, and the referenced
+   * structure MUST be in the form of a Path Item Object. In case a Path Item Object field appears both in the defined
+   * object and the referenced object, the behavior is undefined. See the rules for resolving Relative References.
+   *
+   * Note: The behavior of $ref with adjacent properties is likely to change in future versions of this specification to
+   * bring it into closer alignment with the behavior of the Reference Object.
+   *
+   * Q: Why don’t we just use `ReferenceObjectSchema`?
+   * A: References work a little bit different here. It’s the only place where they can be combined with other
+   *    properties.
+   */
+  "$ref": z.string().optional(),
+  /**
+   * A definition of a GET operation on this path.
+   */
+  get: OperationObjectSchema.optional(),
+  /**
+   * A definition of a PUT operation on this path.
+   */
+  put: OperationObjectSchema.optional(),
+  /**
+   * A definition of a POST operation on this path.
+   */
+  post: OperationObjectSchema.optional(),
+  /**
+   * A definition of a DELETE operation on this path.
+   */
+  delete: OperationObjectSchema.optional(),
+  /**
+   * A definition of a OPTIONS operation on this path.
+   */
+  options: OperationObjectSchema.optional(),
+  /**
+   * A definition of a HEAD operation on this path.
+   */
+  head: OperationObjectSchema.optional(),
+  /**
+   * A definition of a PATCH operation on this path.
+   */
+  patch: OperationObjectSchema.optional(),
+  /**
+   * A definition of a TRACE operation on this path.
+   */
+  trace: OperationObjectSchema.optional()
 });
-
-export { PathItemObjectSchema };
+export {
+  PathItemObjectSchema
+};
+//# sourceMappingURL=path-item-object.js.map

package/dist/schemas/3.1/unprocessed/path-item-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/path-item-object.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport { BasePathItemObjectSchema } from './base-path-item-object'\nimport { OperationObjectSchema } from './operation-object'\n\n/**\n * Path Item Object\n *\n * Describes the operations available on a single path. A Path Item MAY be empty, due to ACL constraints. The path\n * itself is still exposed to the documentation viewer but they will not know which operations and parameters are\n * available.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#path-item-object\n */\nexport const PathItemObjectSchema = BasePathItemObjectSchema.extend({\n  /**\n   * Allows for a referenced definition of this path item. The value MUST be in the form of a URI, and the referenced\n   * structure MUST be in the form of a Path Item Object. In case a Path Item Object field appears both in the defined\n   * object and the referenced object, the behavior is undefined. See the rules for resolving Relative References.\n   *\n   * Note: The behavior of $ref with adjacent properties is likely to change in future versions of this specification to\n   * bring it into closer alignment with the behavior of the Reference Object.\n   *\n   * Q: Why don\u2019t we just use `ReferenceObjectSchema`?\n   * A: References work a little bit different here. It\u2019s the only place where they can be combined with other\n   *    properties.\n   */\n  '$ref': z.string().optional(),\n  /**\n   * A definition of a GET operation on this path.\n   */\n  get: OperationObjectSchema.optional(),\n  /**\n   * A definition of a PUT operation on this path.\n   */\n  put: OperationObjectSchema.optional(),\n  /**\n   * A definition of a POST operation on this path.\n   */\n  post: OperationObjectSchema.optional(),\n  /**\n   * A definition of a DELETE operation on this path.\n   */\n  delete: OperationObjectSchema.optional(),\n  /**\n   * A definition of a OPTIONS operation on this path.\n   */\n  options: OperationObjectSchema.optional(),\n  /**\n   * A definition of a HEAD operation on this path.\n   */\n  head: OperationObjectSchema.optional(),\n  /**\n   * A definition of a PATCH operation on this path.\n   */\n  patch: OperationObjectSchema.optional(),\n  /**\n   * A definition of a TRACE operation on this path.\n   */\n  trace: OperationObjectSchema.optional(),\n})\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAClB,SAAS,gCAAgC;AACzC,SAAS,6BAA6B;AAW/B,MAAM,uBAAuB,yBAAyB,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAalE,QAAQ,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA,EAI5B,KAAK,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAIpC,KAAK,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAIpC,MAAM,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAIrC,QAAQ,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAIvC,SAAS,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAIxC,MAAM,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,sBAAsB,SAAS;AAAA;AAAA;AAAA;AAAA,EAItC,OAAO,sBAAsB,SAAS;AACxC,CAAC;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/paths-object.js

@@ -1,14 +1,6 @@
-import { PathsObjectSchema as PathsObjectSchema$1 } from '../processed/paths-object.js';
-
-/**
- * Paths Object
- *
- * Holds the relative paths to the individual endpoints and their operations. The path is appended to the URL from the
- * Server Object in order to construct the full URL. The Paths Object MAY be empty, due to Access Control List (ACL)
- * constraints.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#paths-object
- */
-const PathsObjectSchema = PathsObjectSchema$1;
-
-export { PathsObjectSchema };
+import { PathsObjectSchema as OriginalPathsObjectSchema } from "../processed/paths-object.js";
+const PathsObjectSchema = OriginalPathsObjectSchema;
+export {
+  PathsObjectSchema
+};
+//# sourceMappingURL=paths-object.js.map

package/dist/schemas/3.1/unprocessed/paths-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/paths-object.ts"],
+  "sourcesContent": ["import { PathsObjectSchema as OriginalPathsObjectSchema } from '../processed/paths-object'\n\n/**\n * Paths Object\n *\n * Holds the relative paths to the individual endpoints and their operations. The path is appended to the URL from the\n * Server Object in order to construct the full URL. The Paths Object MAY be empty, due to Access Control List (ACL)\n * constraints.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#paths-object\n */\nexport const PathsObjectSchema = OriginalPathsObjectSchema\n"],
+  "mappings": "AAAA,SAAS,qBAAqB,iCAAiC;AAWxD,MAAM,oBAAoB;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/reference-object.js

@@ -1,30 +1,22 @@
-import { z } from 'zod';
-
-/**
- * Reference Object
- *
- * A simple object to allow referencing other components in the OpenAPI Description, internally and externally.
- *
- * The $ref string value contains a URI RFC3986, which identifies the value being referenced.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#reference-object
- */
+import { z } from "zod";
 const ReferenceObjectSchema = z.object({
-    /**
-     * REQUIRED. The reference identifier. This MUST be in the form of a URI.
-     */
-    $ref: z.string(),
-    /**
-     * A short summary which by default SHOULD override that of the referenced component. If the referenced object-type
-     * does not allow a summary field, then this field has no effect.
-     */
-    summary: z.string().optional(),
-    /**
-     * A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for
-     * rich text representation. If the referenced object-type does not allow a description field, then this field has no
-     * effect.
-     */
-    description: z.string().optional(),
+  /**
+   * REQUIRED. The reference identifier. This MUST be in the form of a URI.
+   */
+  $ref: z.string(),
+  /**
+   * A short summary which by default SHOULD override that of the referenced component. If the referenced object-type
+   * does not allow a summary field, then this field has no effect.
+   */
+  summary: z.string().optional(),
+  /**
+   * A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for
+   * rich text representation. If the referenced object-type does not allow a description field, then this field has no
+   * effect.
+   */
+  description: z.string().optional()
 });
-
-export { ReferenceObjectSchema };
+export {
+  ReferenceObjectSchema
+};
+//# sourceMappingURL=reference-object.js.map

package/dist/schemas/3.1/unprocessed/reference-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/reference-object.ts"],
+  "sourcesContent": ["import { z } from 'zod'\n\n/**\n * Reference Object\n *\n * A simple object to allow referencing other components in the OpenAPI Description, internally and externally.\n *\n * The $ref string value contains a URI RFC3986, which identifies the value being referenced.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#reference-object\n */\nexport const ReferenceObjectSchema = z.object({\n  /**\n   * REQUIRED. The reference identifier. This MUST be in the form of a URI.\n   */\n  $ref: z.string(),\n  /**\n   * A short summary which by default SHOULD override that of the referenced component. If the referenced object-type\n   * does not allow a summary field, then this field has no effect.\n   */\n  summary: z.string().optional(),\n  /**\n   * A description which by default SHOULD override that of the referenced component. CommonMark syntax MAY be used for\n   * rich text representation. If the referenced object-type does not allow a description field, then this field has no\n   * effect.\n   */\n  description: z.string().optional(),\n})\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAWX,MAAM,wBAAwB,EAAE,OAAO;AAAA;AAAA;AAAA;AAAA,EAI5C,MAAM,EAAE,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAKf,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM7B,aAAa,EAAE,OAAO,EAAE,SAAS;AACnC,CAAC;",
+  "names": []
+}

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

@@ -1,12 +1,6 @@
-import { RequestBodyObjectSchema as RequestBodyObjectSchema$1 } from '../processed/request-body-object.js';
-
-/**
- * Request Body Object
- *
- * Describes a single request body.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#request-body-object
- */
-const RequestBodyObjectSchema = RequestBodyObjectSchema$1;
-
-export { RequestBodyObjectSchema };
+import { RequestBodyObjectSchema as OriginalRequestBodyObjectSchema } from "../processed/request-body-object.js";
+const RequestBodyObjectSchema = OriginalRequestBodyObjectSchema;
+export {
+  RequestBodyObjectSchema
+};
+//# sourceMappingURL=request-body-object.js.map

package/dist/schemas/3.1/unprocessed/request-body-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/request-body-object.ts"],
+  "sourcesContent": ["import { RequestBodyObjectSchema as OriginalRequestBodyObjectSchema } from '../processed/request-body-object'\n\n/**\n * Request Body Object\n *\n * Describes a single request body.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#request-body-object\n */\nexport const RequestBodyObjectSchema = OriginalRequestBodyObjectSchema\n"],
+  "mappings": "AAAA,SAAS,2BAA2B,uCAAuC;AASpE,MAAM,0BAA0B;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/response-object.js

@@ -1,34 +1,28 @@
-import { z } from 'zod';
-import { ResponseObjectSchema as ResponseObjectSchema$1 } from '../processed/response-object.js';
-import { HeaderObjectSchema } from './header-object.js';
-import { LinkObjectSchema } from './link-object.js';
-import { MediaTypeObjectSchema } from './media-type-object.js';
-import { ReferenceObjectSchema } from './reference-object.js';
-
-/**
- * Response Object
- *
- * Describes a single response from an API operation, including design-time, static links to operations based on the response.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#response-object
- */
-const ResponseObjectSchema = ResponseObjectSchema$1.extend({
-    /**
-     * Maps a header name to its definition. RFC7230 states header names are case insensitive. If a response header is
-     * defined with the name "Content-Type", it SHALL be ignored.
-     */
-    headers: z.record(z.string(), z.union([ReferenceObjectSchema, HeaderObjectSchema])).optional(),
-    /**
-     * A map containing descriptions of potential response payloads. The key is a media type or media type range and the
-     * value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g.
-     * "text/plain" overrides "text/*"
-     */
-    content: z.record(z.string(), MediaTypeObjectSchema).optional(),
-    /**
-     * A map of operations links that can be followed from the response. The key of the map is a short name for the link,
-     * following the naming constraints of the names for Component Objects.
-     */
-    links: z.record(z.string(), z.union([ReferenceObjectSchema, LinkObjectSchema])).optional(),
+import { z } from "zod";
+import { ResponseObjectSchema as OriginalResponseObjectSchema } from "../processed/response-object.js";
+import { HeaderObjectSchema } from "./header-object.js";
+import { LinkObjectSchema } from "./link-object.js";
+import { MediaTypeObjectSchema } from "./media-type-object.js";
+import { ReferenceObjectSchema } from "./reference-object.js";
+const ResponseObjectSchema = OriginalResponseObjectSchema.extend({
+  /**
+   * Maps a header name to its definition. RFC7230 states header names are case insensitive. If a response header is
+   * defined with the name "Content-Type", it SHALL be ignored.
+   */
+  headers: z.record(z.string(), z.union([ReferenceObjectSchema, HeaderObjectSchema])).optional(),
+  /**
+   * A map containing descriptions of potential response payloads. The key is a media type or media type range and the
+   * value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g.
+   * "text/plain" overrides "text/*"
+   */
+  content: z.record(z.string(), MediaTypeObjectSchema).optional(),
+  /**
+   * A map of operations links that can be followed from the response. The key of the map is a short name for the link,
+   * following the naming constraints of the names for Component Objects.
+   */
+  links: z.record(z.string(), z.union([ReferenceObjectSchema, LinkObjectSchema])).optional()
 });
-
-export { ResponseObjectSchema };
+export {
+  ResponseObjectSchema
+};
+//# sourceMappingURL=response-object.js.map

package/dist/schemas/3.1/unprocessed/response-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/response-object.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport { ResponseObjectSchema as OriginalResponseObjectSchema } from '../processed/response-object'\nimport { HeaderObjectSchema } from './header-object'\nimport { LinkObjectSchema } from './link-object'\nimport { MediaTypeObjectSchema } from './media-type-object'\nimport { ReferenceObjectSchema } from './reference-object'\n\n/**\n * Response Object\n *\n * Describes a single response from an API operation, including design-time, static links to operations based on the response.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#response-object\n */\nexport const ResponseObjectSchema = OriginalResponseObjectSchema.extend({\n  /**\n   * Maps a header name to its definition. RFC7230 states header names are case insensitive. If a response header is\n   * defined with the name \"Content-Type\", it SHALL be ignored.\n   */\n  headers: z.record(z.string(), z.union([ReferenceObjectSchema, HeaderObjectSchema])).optional(),\n  /**\n   * A map containing descriptions of potential response payloads. The key is a media type or media type range and the\n   * value describes it. For responses that match multiple keys, only the most specific key is applicable. e.g.\n   * \"text/plain\" overrides \"text/*\"\n   */\n  content: z.record(z.string(), MediaTypeObjectSchema).optional(),\n  /**\n   * A map of operations links that can be followed from the response. The key of the map is a short name for the link,\n   * following the naming constraints of the names for Component Objects.\n   */\n  links: z.record(z.string(), z.union([ReferenceObjectSchema, LinkObjectSchema])).optional(),\n})\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAClB,SAAS,wBAAwB,oCAAoC;AACrE,SAAS,0BAA0B;AACnC,SAAS,wBAAwB;AACjC,SAAS,6BAA6B;AACtC,SAAS,6BAA6B;AAS/B,MAAM,uBAAuB,6BAA6B,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtE,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,MAAM,CAAC,uBAAuB,kBAAkB,CAAC,CAAC,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM7F,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,qBAAqB,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,EAK9D,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,MAAM,CAAC,uBAAuB,gBAAgB,CAAC,CAAC,EAAE,SAAS;AAC3F,CAAC;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/responses-object.js

@@ -1,32 +1,19 @@
-import { z } from 'zod';
-import { ReferenceObjectSchema } from './reference-object.js';
-import { ResponseObjectSchema } from './response-object.js';
-
-/**
- * Responses Object
- *
- * A container for the expected responses of an operation. The container maps a HTTP response code to the expected
- * response.
- *
- * The documentation is not necessarily expected to cover all possible HTTP response codes because they may not be known
- *  in advance. However, documentation is expected to cover a successful operation response and any known errors.
- * The default MAY be used as a default Response Object for all HTTP codes that are not covered individually by the
- * Responses Object.
- *
- * The Responses Object MUST contain at least one response code, and if only one response code is provided it SHOULD be
- * the response for a successful operation call.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#responses-object
- */
+import { z } from "zod";
+import { ReferenceObjectSchema } from "./reference-object.js";
+import { ResponseObjectSchema } from "./response-object.js";
 const ResponsesObjectSchema = z.record(
-/**
- * Response Object | Reference Object	Any HTTP status code can be used as the property name, but only one property per
- *  code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks
- * (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY
- * contain the uppercase wildcard character X. For example, 2XX represents all response codes between 200 and 299.
- * Only the following range definitions are allowed: 1XX, 2XX, 3XX, 4XX, and 5XX. If a response is defined using an
- * explicit code, the explicit code definition takes precedence over the range definition for that code.
- */
-z.string(), z.union([ReferenceObjectSchema, ResponseObjectSchema]));
-
-export { ResponsesObjectSchema };
+  /**
+   * Response Object | Reference Object	Any HTTP status code can be used as the property name, but only one property per
+   *  code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks
+   * (for example, "200") for compatibility between JSON and YAML. To define a range of response codes, this field MAY
+   * contain the uppercase wildcard character X. For example, 2XX represents all response codes between 200 and 299.
+   * Only the following range definitions are allowed: 1XX, 2XX, 3XX, 4XX, and 5XX. If a response is defined using an
+   * explicit code, the explicit code definition takes precedence over the range definition for that code.
+   */
+  z.string(),
+  z.union([ReferenceObjectSchema, ResponseObjectSchema])
+);
+export {
+  ResponsesObjectSchema
+};
+//# sourceMappingURL=responses-object.js.map

package/dist/schemas/3.1/unprocessed/responses-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/responses-object.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport { ReferenceObjectSchema } from './reference-object'\nimport { ResponseObjectSchema } from './response-object'\n\n/**\n * Responses Object\n *\n * A container for the expected responses of an operation. The container maps a HTTP response code to the expected\n * response.\n *\n * The documentation is not necessarily expected to cover all possible HTTP response codes because they may not be known\n *  in advance. However, documentation is expected to cover a successful operation response and any known errors.\n * The default MAY be used as a default Response Object for all HTTP codes that are not covered individually by the\n * Responses Object.\n *\n * The Responses Object MUST contain at least one response code, and if only one response code is provided it SHOULD be\n * the response for a successful operation call.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#responses-object\n */\nexport const ResponsesObjectSchema = z.record(\n  /**\n   * Response Object | Reference Object\tAny HTTP status code can be used as the property name, but only one property per\n   *  code, to describe the expected response for that HTTP status code. This field MUST be enclosed in quotation marks\n   * (for example, \"200\") for compatibility between JSON and YAML. To define a range of response codes, this field MAY\n   * contain the uppercase wildcard character X. For example, 2XX represents all response codes between 200 and 299.\n   * Only the following range definitions are allowed: 1XX, 2XX, 3XX, 4XX, and 5XX. If a response is defined using an\n   * explicit code, the explicit code definition takes precedence over the range definition for that code.\n   */\n  z.string(),\n  z.union([ReferenceObjectSchema, ResponseObjectSchema]),\n)\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAClB,SAAS,6BAA6B;AACtC,SAAS,4BAA4B;AAkB9B,MAAM,wBAAwB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASrC,EAAE,OAAO;AAAA,EACT,EAAE,MAAM,CAAC,uBAAuB,oBAAoB,CAAC;AACvD;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/runtime-expression.js

@@ -1,17 +1,6 @@
-import { RuntimeExpressionSchema as RuntimeExpressionSchema$1 } from '../processed/runtime-expression.js';
-
-/**
- * Runtime Expression Schema
- *
- * Runtime expressions allow defining values based on information that will only be available within the HTTP message in
- * an actual API call. This mechanism is used by Link Objects and Callback Objects.
- *
- * Expressions can be:
- * 1. Pure runtime expressions starting with $ (e.g. $method, $request.path.id)
- * 2. Embedded expressions in strings using curly braces (e.g. "Hello {$request.body#/name}!")
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#runtime-expressions
- */
-const RuntimeExpressionSchema = RuntimeExpressionSchema$1;
-
-export { RuntimeExpressionSchema };
+import { RuntimeExpressionSchema as OriginalRuntimeExpressionSchema } from "../processed/runtime-expression.js";
+const RuntimeExpressionSchema = OriginalRuntimeExpressionSchema;
+export {
+  RuntimeExpressionSchema
+};
+//# sourceMappingURL=runtime-expression.js.map

package/dist/schemas/3.1/unprocessed/runtime-expression.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/runtime-expression.ts"],
+  "sourcesContent": ["import { RuntimeExpressionSchema as OriginalRuntimeExpressionSchema } from '../processed/runtime-expression'\n\n/**\n * Runtime Expression Schema\n *\n * Runtime expressions allow defining values based on information that will only be available within the HTTP message in\n * an actual API call. This mechanism is used by Link Objects and Callback Objects.\n *\n * Expressions can be:\n * 1. Pure runtime expressions starting with $ (e.g. $method, $request.path.id)\n * 2. Embedded expressions in strings using curly braces (e.g. \"Hello {$request.body#/name}!\")\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#runtime-expressions\n */\nexport const RuntimeExpressionSchema = OriginalRuntimeExpressionSchema\n"],
+  "mappings": "AAAA,SAAS,2BAA2B,uCAAuC;AAcpE,MAAM,0BAA0B;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/schema-object.js

@@ -1,32 +1,31 @@
-import { z } from 'zod';
-import { SchemaObjectSchema as SchemaObjectSchema$1 } from '../processed/schema-object.js';
-import { ReferenceObjectSchema } from './reference-object.js';
-
-/**
- * The Schema Object with reference fields.
- * This extends the base Schema Object to include reference-related fields
- * that are processed differently in the unprocessed schema.
- */
-const SchemaObjectSchema = z.lazy(() => z.intersection(SchemaObjectSchema$1, z.object({
-    // Reference-related fields
-    $ref: z.string().optional(),
-    $id: z.string().optional(),
-    $schema: z.string().optional(),
-    $defs: z.record(z.lazy(() => SchemaObjectSchema)).optional(),
-    $dynamicRef: z.string().optional(),
-    $dynamicAnchor: z.string().optional(),
-    // Override the recursive fields to use this schema instead of the original
-    properties: z.record(z.string(), z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
-    additionalProperties: z.union([z.boolean(), z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),
-    patternProperties: z
-        .record(z.string(), z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]))
-        .optional(),
-    items: z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),
-    prefixItems: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
-    allOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
-    oneOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
-    anyOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
-    not: z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),
-})));
-
-export { SchemaObjectSchema };
+import { z } from "zod";
+import { SchemaObjectSchema as OriginalSchemaObjectSchema } from "../processed/schema-object.js";
+import { ReferenceObjectSchema } from "./reference-object.js";
+const SchemaObjectSchema = z.lazy(
+  () => z.intersection(
+    OriginalSchemaObjectSchema,
+    z.object({
+      // Reference-related fields
+      $ref: z.string().optional(),
+      $id: z.string().optional(),
+      $schema: z.string().optional(),
+      $defs: z.record(z.lazy(() => SchemaObjectSchema)).optional(),
+      $dynamicRef: z.string().optional(),
+      $dynamicAnchor: z.string().optional(),
+      // Override the recursive fields to use this schema instead of the original
+      properties: z.record(z.string(), z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
+      additionalProperties: z.union([z.boolean(), z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),
+      patternProperties: z.record(z.string(), z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
+      items: z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),
+      prefixItems: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
+      allOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
+      oneOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
+      anyOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),
+      not: z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional()
+    })
+  )
+);
+export {
+  SchemaObjectSchema
+};
+//# sourceMappingURL=schema-object.js.map

package/dist/schemas/3.1/unprocessed/schema-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/schema-object.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport { SchemaObjectSchema as OriginalSchemaObjectSchema } from '../processed/schema-object'\nimport { ReferenceObjectSchema } from './reference-object'\n\n/**\n * The Schema Object with reference fields.\n * This extends the base Schema Object to include reference-related fields\n * that are processed differently in the unprocessed schema.\n */\nexport const SchemaObjectSchema: z.ZodType<any> = z.lazy(() =>\n  z.intersection(\n    OriginalSchemaObjectSchema,\n    z.object({\n      // Reference-related fields\n      $ref: z.string().optional(),\n      $id: z.string().optional(),\n      $schema: z.string().optional(),\n      $defs: z.record(z.lazy(() => SchemaObjectSchema)).optional(),\n      $dynamicRef: z.string().optional(),\n      $dynamicAnchor: z.string().optional(),\n\n      // Override the recursive fields to use this schema instead of the original\n      properties: z.record(z.string(), z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),\n      additionalProperties: z.union([z.boolean(), z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),\n      patternProperties: z\n        .record(z.string(), z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]))\n        .optional(),\n      items: z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),\n      prefixItems: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),\n      allOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),\n      oneOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),\n      anyOf: z.array(z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema])).optional(),\n      not: z.union([z.lazy(() => SchemaObjectSchema), ReferenceObjectSchema]).optional(),\n    }),\n  ),\n)\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAClB,SAAS,sBAAsB,kCAAkC;AACjE,SAAS,6BAA6B;AAO/B,MAAM,qBAAqC,EAAE;AAAA,EAAK,MACvD,EAAE;AAAA,IACA;AAAA,IACA,EAAE,OAAO;AAAA;AAAA,MAEP,MAAM,EAAE,OAAO,EAAE,SAAS;AAAA,MAC1B,KAAK,EAAE,OAAO,EAAE,SAAS;AAAA,MACzB,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA,MAC7B,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,kBAAkB,CAAC,EAAE,SAAS;AAAA,MAC3D,aAAa,EAAE,OAAO,EAAE,SAAS;AAAA,MACjC,gBAAgB,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA,MAGpC,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,EAAE,SAAS;AAAA,MAC9G,sBAAsB,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,EAAE,SAAS;AAAA,MAC/G,mBAAmB,EAChB,OAAO,EAAE,OAAO,GAAG,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,EACrF,SAAS;AAAA,MACZ,OAAO,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,EAAE,SAAS;AAAA,MACnF,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,EAAE,SAAS;AAAA,MAClG,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,EAAE,SAAS;AAAA,MAC5F,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,EAAE,SAAS;AAAA,MAC5F,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,EAAE,SAAS;AAAA,MAC5F,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,EAAE,SAAS;AAAA,IACnF,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/schemas/3.1/unprocessed/security-requirement-object.js

@@ -1,23 +1,6 @@
-import { SecurityRequirementObjectSchema as SecurityRequirementObjectSchema$1 } from '../processed/security-requirement-object.js';
-
-/**
- * Security Requirement Object
- *
- * Lists the required security schemes to execute this operation. The name used for each property MUST correspond to a
- * security scheme declared in the Security Schemes under the Components Object.
- *
- * A Security Requirement Object MAY refer to multiple security schemes in which case all schemes MUST be satisfied for
- * a request to be authorized. This enables support for scenarios where multiple query parameters or HTTP headers are
- * required to convey security information.
- *
- * When the security field is defined on the OpenAPI Object or Operation Object and contains multiple Security
- * Requirement Objects, only one of the entries in the list needs to be satisfied to authorize the request. This
- * enables support for scenarios where the API allows multiple, independent security schemes.
- *
- * An empty Security Requirement Object ({}) indicates anonymous access is supported.
- *
- * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#security-requirement-object
- */
-const SecurityRequirementObjectSchema = SecurityRequirementObjectSchema$1;
-
-export { SecurityRequirementObjectSchema };
+import { SecurityRequirementObjectSchema as OriginalSecurityRequirementObjectSchema } from "../processed/security-requirement-object.js";
+const SecurityRequirementObjectSchema = OriginalSecurityRequirementObjectSchema;
+export {
+  SecurityRequirementObjectSchema
+};
+//# sourceMappingURL=security-requirement-object.js.map

package/dist/schemas/3.1/unprocessed/security-requirement-object.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/schemas/3.1/unprocessed/security-requirement-object.ts"],
+  "sourcesContent": ["import { SecurityRequirementObjectSchema as OriginalSecurityRequirementObjectSchema } from '../processed/security-requirement-object'\n\n/**\n * Security Requirement Object\n *\n * Lists the required security schemes to execute this operation. The name used for each property MUST correspond to a\n * security scheme declared in the Security Schemes under the Components Object.\n *\n * A Security Requirement Object MAY refer to multiple security schemes in which case all schemes MUST be satisfied for\n * a request to be authorized. This enables support for scenarios where multiple query parameters or HTTP headers are\n * required to convey security information.\n *\n * When the security field is defined on the OpenAPI Object or Operation Object and contains multiple Security\n * Requirement Objects, only one of the entries in the list needs to be satisfied to authorize the request. This\n * enables support for scenarios where the API allows multiple, independent security schemes.\n *\n * An empty Security Requirement Object ({}) indicates anonymous access is supported.\n *\n * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#security-requirement-object\n */\nexport const SecurityRequirementObjectSchema = OriginalSecurityRequirementObjectSchema\n"],
+  "mappings": "AAAA,SAAS,mCAAmC,+CAA+C;AAoBpF,MAAM,kCAAkC;",
+  "names": []
+}