@scalar/schemas 0.2.0 → 0.3.1

package/dist/openapi/3.1/media-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-type.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/media-type.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAUZ,MAAM,oBAAoB,CAAA;AAmE3B,eAAO,MAAM,MAAM,6LAA6E,CAAA;AAEhG,eAAO,MAAM,QAAQ;;;EAWpB,CAAA;AAED,eAAO,MAAM,SAAS;;;;;;;;EAcrB,CAAA"}

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

@@ -0,0 +1,49 @@
+import { any, boolean, intersection, lazy, object, optional, record, string, union, } from '@scalar/validation';
+import { example } from '../../openapi/3.1/example.js';
+import { normalRef, recursiveRef } from '../../openapi/3.1/reference.js';
+import { schema } from '../../openapi/3.1/schema.js';
+const headerBase = object({
+    description: optional(string({
+        typeComment: 'A brief description of the header. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    required: optional(boolean({ typeComment: 'Determines whether this header is mandatory. The default value is false.' })),
+    deprecated: optional(boolean({
+        typeComment: 'Specifies that the header is deprecated and SHOULD be transitioned out of usage. Default value is false.',
+    })),
+}, { typeName: 'HeaderBase' });
+const headerWithSchema = intersection([
+    headerBase,
+    object({
+        style: optional(string({
+            typeComment: 'Describes how the header value will be serialized. The default (and only legal value for headers) is "simple".',
+        })),
+        explode: optional(boolean({
+            typeComment: 'When this is true, header values of type array or object generate a single header whose value is a comma-separated list of the array items or key-value pairs of the map, see Style Examples.',
+        })),
+        schema: optional(normalRef(lazy(() => schema))),
+        example: optional(any()),
+        examples: optional(record(string(), recursiveRef(lazy(() => example)), { typeName: 'HeaderExamples' })),
+    }, { typeName: 'HeaderObjectWithSchema' }),
+]);
+const headerWithContent = intersection([
+    headerBase,
+    object({
+        content: optional(record(string(), lazy(() => mediaType), { typeName: 'HeaderContent' })),
+    }, { typeName: 'HeaderObjectWithContent' }),
+]);
+export const header = union([headerWithSchema, headerWithContent], { typeName: 'HeaderObject' });
+export const encoding = object({
+    contentType: optional(string({
+        typeComment: 'The Content-Type for encoding a specific property. The value is a comma-separated list, each element of which is either a specific media type (e.g. image/png) or a wildcard media type (e.g. image/*).',
+    })),
+    headers: optional(record(string(), recursiveRef(lazy(() => header)), { typeName: 'EncodingHeaders' })),
+}, { typeName: 'EncodingObject' });
+export const mediaType = object({
+    schema: optional(normalRef(lazy(() => schema))),
+    example: optional(any({ typeComment: 'Example of the media type.' })),
+    examples: optional(record(string(), recursiveRef(lazy(() => example)), { typeName: 'MediaTypeExamples' })),
+    encoding: optional(record(string(), encoding, {
+        typeComment: 'A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property.',
+        typeName: 'MediaTypeEncoding',
+    })),
+}, { typeName: 'MediaTypeObject' });

package/dist/openapi/3.1/operation.d.ts

@@ -0,0 +1,68 @@
+export declare const operation: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    tags: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    externalDocs: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>;
+    operationId: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    parameters: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").Schema>>;
+    requestBody: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    responses: import("@scalar/validation").OptionalSchema<import("@scalar/validation").LazySchema<() => import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>>;
+    deprecated: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    security: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>>>;
+    servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        variables: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+            enum: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+            default: import("@scalar/validation").StringSchema;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+    }>>>;
+    callbacks: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-badges': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        position: import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"before">, import("@scalar/validation").LiteralSchema<"after">]>>;
+        color: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-internal': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-ignore': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-codeSamples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
+    'x-code-samples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
+    'x-custom-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        label: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        source: import("@scalar/validation").StringSchema;
+    }>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-stability': import("@scalar/validation").OptionalSchema<import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"deprecated">, import("@scalar/validation").LiteralSchema<"experimental">, import("@scalar/validation").LiteralSchema<"stable">]>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-disable-parameters': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        'global-cookies': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>>;
+        'global-headers': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>>;
+        'default-headers': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").BooleanSchema>>>;
+    }>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-post-response': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-pre-request': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-draft-examples': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-selected-server': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>]>;
+//# sourceMappingURL=operation.d.ts.map

package/dist/openapi/3.1/operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/operation.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiDrB,CAAA"}

package/dist/openapi/3.1/operation.js

@@ -0,0 +1,48 @@
+import { array, boolean, intersection, lazy, object, optional, record, string } from '@scalar/validation';
+import { XInternal, XScalarIgnore } from '../../extensions/document/index.js';
+import { XPostResponse, XPreRequest } from '../../extensions/general/index.js';
+import { XBadges, XCodeSamples, XDraftExamples, XScalarDisableParameters, XScalarStability, } from '../../extensions/operation/index.js';
+import { XScalarSelectedServer } from '../../extensions/server/index.js';
+import { callback } from '../../openapi/3.1/callback.js';
+import { externalDocs } from '../../openapi/3.1/external-docs.js';
+import { parameter } from '../../openapi/3.1/parameter.js';
+import { recursiveRef } from '../../openapi/3.1/reference.js';
+import { requestBody } from '../../openapi/3.1/request-body.js';
+import { responsesObject } from '../../openapi/3.1/response.js';
+import { securityRequirement } from '../../openapi/3.1/security-requirement.js';
+import { server } from '../../openapi/3.1/server.js';
+export const operation = intersection([
+    object({
+        tags: optional(array(string(), {
+            typeComment: 'A list of tags for API documentation control. Tags can be used for logical grouping of operations by resources or any other qualifier.',
+            typeName: 'OperationTags',
+        })),
+        summary: optional(string({ typeComment: 'A short summary of what the operation does.' })),
+        description: optional(string({
+            typeComment: 'A verbose explanation of the operation behavior. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        externalDocs: optional(externalDocs),
+        operationId: optional(string({
+            typeComment: 'Unique string used to identify the operation. The id MUST be unique among all operations described in the API. The operationId value is case-sensitive.',
+        })),
+        parameters: optional(array(recursiveRef(lazy(() => parameter)), { typeName: 'OperationParameters' })),
+        requestBody: optional(recursiveRef(lazy(() => requestBody))),
+        responses: optional(lazy(() => responsesObject)),
+        deprecated: optional(boolean({
+            typeComment: 'Declares this operation to be deprecated. Consumers SHOULD refrain from usage of the declared operation. Default value is false.',
+        })),
+        security: optional(array(securityRequirement, { typeName: 'OperationSecurity' })),
+        servers: optional(array(server, { typeName: 'OperationServers' })),
+        callbacks: optional(record(string(), recursiveRef(lazy(() => callback)), { typeName: 'OperationCallbacks' })),
+    }),
+    XBadges,
+    XInternal,
+    XScalarIgnore,
+    XCodeSamples,
+    XScalarStability,
+    XScalarDisableParameters,
+    XPostResponse,
+    XPreRequest,
+    XDraftExamples,
+    XScalarSelectedServer,
+], { typeName: 'OperationObject' });

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

@@ -0,0 +1,44 @@
+export declare const parameter: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    in: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"query">, import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"path">, import("@scalar/validation").LiteralSchema<"cookie">]>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    required: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    deprecated: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    allowEmptyValue: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    allowReserved: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    style: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    explode: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    schema: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    example: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-global': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-internal': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-ignore': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>]>, import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    in: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").LiteralSchema<"query">, import("@scalar/validation").LiteralSchema<"header">, import("@scalar/validation").LiteralSchema<"path">, import("@scalar/validation").LiteralSchema<"cookie">]>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    required: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    deprecated: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    allowEmptyValue: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    allowReserved: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    content: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+        schema: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        example: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+        examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        encoding: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+            contentType: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            headers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        }>>>;
+    }>>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-global': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-internal': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-ignore': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>]>]>;
+//# sourceMappingURL=parameter.d.ts.map

package/dist/openapi/3.1/parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/parameter.ts"],"names":[],"mappings":"AAkIA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAsF,CAAA"}

package/dist/openapi/3.1/parameter.js

@@ -0,0 +1,76 @@
+import { any, boolean, intersection, lazy, literal, object, optional, record, string, union } from '@scalar/validation';
+import { XInternal, XScalarIgnore } from '../../extensions/document/index.js';
+import { XGlobal } from '../../extensions/parameter/index.js';
+import { example } from '../../openapi/3.1/example.js';
+import { mediaType } from '../../openapi/3.1/media-type.js';
+import { normalRef, recursiveRef } from '../../openapi/3.1/reference.js';
+import { schema } from '../../openapi/3.1/schema.js';
+const parameterWithSchema = intersection([
+    object({
+        name: string({
+            typeComment: 'REQUIRED. The name of the parameter. Parameter names are case sensitive. If in is "path", the name field MUST correspond to a template expression occurring within the path field in the Paths Object.',
+        }),
+        in: union([literal('query'), literal('header'), literal('path'), literal('cookie')], {
+            typeName: 'ParameterLocation',
+            typeComment: 'REQUIRED. The location of the parameter. Possible values are "query", "header", "path" or "cookie".',
+        }),
+        description: optional(string({
+            typeComment: 'A brief description of the parameter. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        required: optional(boolean({
+            typeComment: 'Determines whether this parameter is mandatory. If the parameter location is "path", this field is REQUIRED and its value MUST be true.',
+        })),
+        deprecated: optional(boolean({
+            typeComment: 'Specifies that a parameter is deprecated and SHOULD be transitioned out of usage. Default value is false.',
+        })),
+        allowEmptyValue: optional(boolean({
+            typeComment: 'If true, clients MAY pass a zero-length string value in place of parameters that would otherwise be omitted entirely. This field is valid only for query parameters.',
+        })),
+        allowReserved: optional(boolean({
+            typeComment: 'When this is true, parameter values are serialized using reserved expansion, as defined by RFC6570. This field only applies to parameters with an in value of query. The default value is false.',
+        })),
+        style: optional(string({
+            typeComment: 'Describes how the parameter value will be serialized (depending on the schema type).',
+        })),
+        explode: optional(boolean({
+            typeComment: 'When this is true, parameter values of type array or object generate separate parameters for each array item or object property.',
+        })),
+        schema: optional(normalRef(lazy(() => schema))),
+        example: optional(any()),
+        examples: optional(record(string(), recursiveRef(lazy(() => example)), { typeName: 'ParameterExamples' })),
+    }),
+    XGlobal,
+    XInternal,
+    XScalarIgnore,
+], { typeName: 'ParameterObjectWithSchema' });
+const parameterWithContent = intersection([
+    object({
+        name: string({
+            typeComment: 'REQUIRED. The name of the parameter. Parameter names are case sensitive. If in is "path", the name field MUST correspond to a template expression occurring within the path field in the Paths Object.',
+        }),
+        in: union([literal('query'), literal('header'), literal('path'), literal('cookie')], {
+            typeName: 'ParameterLocation',
+            typeComment: 'REQUIRED. The location of the parameter. Possible values are "query", "header", "path" or "cookie".',
+        }),
+        description: optional(string({
+            typeComment: 'A brief description of the parameter. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        required: optional(boolean({
+            typeComment: 'Determines whether this parameter is mandatory. If the parameter location is "path", this field is REQUIRED and its value MUST be true.',
+        })),
+        deprecated: optional(boolean({
+            typeComment: 'Specifies that a parameter is deprecated and SHOULD be transitioned out of usage. Default value is false.',
+        })),
+        allowEmptyValue: optional(boolean({
+            typeComment: 'If true, clients MAY pass a zero-length string value in place of parameters that would otherwise be omitted entirely. This field is valid only for query parameters.',
+        })),
+        allowReserved: optional(boolean({
+            typeComment: 'When this is true, parameter values are serialized using reserved expansion, as defined by RFC6570. This field only applies to parameters with an in value of query. The default value is false.',
+        })),
+        content: optional(record(string(), lazy(() => mediaType), { typeName: 'ParameterContent' })),
+    }),
+    XGlobal,
+    XInternal,
+    XScalarIgnore,
+], { typeName: 'ParameterObjectWithContent' });
+export const parameter = union([parameterWithSchema, parameterWithContent], { typeName: 'ParameterObject' });

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

@@ -0,0 +1,25 @@
+export declare const pathItem: import("@scalar/validation").ObjectSchema<{
+    $ref: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    get: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    put: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    post: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    delete: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    patch: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    connect: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    options: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    head: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    trace: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+    servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        variables: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+            enum: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+            default: import("@scalar/validation").StringSchema;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+    }>>>;
+    parameters: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").Schema>>;
+}>;
+//# sourceMappingURL=path-item.d.ts.map

package/dist/openapi/3.1/path-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-item.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/path-item.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;EAgCpB,CAAA"}

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

@@ -0,0 +1,27 @@
+import { array, lazy, object, optional, string } from '@scalar/validation';
+import { operation } from '../../openapi/3.1/operation.js';
+import { parameter } from '../../openapi/3.1/parameter.js';
+import { recursiveRef } from '../../openapi/3.1/reference.js';
+import { server } from '../../openapi/3.1/server.js';
+export const pathItem = object({
+    $ref: optional(string({
+        typeComment: '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.',
+    })),
+    summary: optional(string({
+        typeComment: 'An optional string summary, intended to apply to all operations in this path.',
+    })),
+    description: optional(string({
+        typeComment: 'An optional string description, intended to apply to all operations in this path. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    get: optional(recursiveRef(lazy(() => operation))),
+    put: optional(recursiveRef(lazy(() => operation))),
+    post: optional(recursiveRef(lazy(() => operation))),
+    delete: optional(recursiveRef(lazy(() => operation))),
+    patch: optional(recursiveRef(lazy(() => operation))),
+    connect: optional(recursiveRef(lazy(() => operation))),
+    options: optional(recursiveRef(lazy(() => operation))),
+    head: optional(recursiveRef(lazy(() => operation))),
+    trace: optional(recursiveRef(lazy(() => operation))),
+    servers: optional(array(server, { typeName: 'PathItemServers' })),
+    parameters: optional(array(recursiveRef(lazy(() => parameter)), { typeName: 'PathItemParameters' })),
+}, { typeName: 'PathItemObject' });

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

@@ -0,0 +1,16 @@
+import { type Schema } from '@scalar/validation';
+/**
+ * Wraps a JSON Schema so it may also be satisfied by a Reference Object (no resolved `$ref-value`).
+ *
+ * Use for `components.schemas` and schema composition (`allOf`, `properties`, `items`, and similar)
+ * where references follow JSON Schema / OpenAPI schema rules only.
+ */
+export declare const normalRef: (inner: Schema) => Schema;
+/**
+ * Inline object or Reference Object with resolved `$ref-value` and bundle extensions.
+ *
+ * Schemas in this folder use {@link recursiveRef} directly. Use {@link recursiveRef} when generating
+ * types for resolved or proxy documents (see `generate-types.ts`).
+ */
+export declare const recursiveRef: (inner: Schema) => Schema;
+//# sourceMappingURL=reference.d.ts.map

package/dist/openapi/3.1/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/reference.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAA2D,MAAM,oBAAoB,CAAA;AAyBzG;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,KAAG,MAAmC,CAAA;AAU7E;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,MACiE,CAAA"}

package/dist/openapi/3.1/reference.js

@@ -0,0 +1,34 @@
+import { isObject } from '@scalar/helpers/object/is-object';
+import { evaluate, intersection, object, optional, string, union } from '@scalar/validation';
+import { referenceExtensions } from '../../general/bundler-extensions.js';
+const reference = object({
+    '$ref': string({ typeComment: 'REQUIRED. The reference identifier. This MUST be in the form of a URI.' }),
+    summary: optional(string({
+        typeComment: '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.',
+    })),
+    description: optional(string({
+        typeComment: '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.',
+    })),
+}, {
+    typeName: 'ReferenceObject',
+});
+/**
+ * Wraps a JSON Schema so it may also be satisfied by a Reference Object (no resolved `$ref-value`).
+ *
+ * Use for `components.schemas` and schema composition (`allOf`, `properties`, `items`, and similar)
+ * where references follow JSON Schema / OpenAPI schema rules only.
+ */
+export const normalRef = (inner) => union([inner, reference]);
+const e = (value) => {
+    if (isObject(value) && '$ref' in value) {
+        return e(value['$ref-value']);
+    }
+    return value;
+};
+/**
+ * Inline object or Reference Object with resolved `$ref-value` and bundle extensions.
+ *
+ * Schemas in this folder use {@link recursiveRef} directly. Use {@link recursiveRef} when generating
+ * types for resolved or proxy documents (see `generate-types.ts`).
+ */
+export const recursiveRef = (inner) => union([inner, intersection([reference, object({ '$ref-value': evaluate(e, inner) }), referenceExtensions])]);

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

@@ -0,0 +1,16 @@
+export declare const requestBody: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    content: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+        schema: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        example: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+        examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        encoding: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+            contentType: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            headers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        }>>>;
+    }>>>;
+    required: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-selected-content-type': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+}>]>;
+//# sourceMappingURL=request-body.d.ts.map

package/dist/openapi/3.1/request-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/request-body.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;IAyBvB,CAAA"}

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

@@ -0,0 +1,16 @@
+import { boolean, intersection, lazy, object, optional, record, string } from '@scalar/validation';
+import { XScalarSelectedContentType } from '../../extensions/operation/index.js';
+import { mediaType } from '../../openapi/3.1/media-type.js';
+export const requestBody = intersection([
+    object({
+        description: optional(string({
+            typeComment: 'A brief description of the request body. This could contain examples of use. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        content: record(string(), lazy(() => mediaType), {
+            typeComment: 'REQUIRED. The content of the request body. The key is a media type or media type range and the value describes it.',
+            typeName: 'RequestBodyContent',
+        }),
+        required: optional(boolean({ typeComment: 'Determines if the request body is required in the request. Defaults to false.' })),
+    }),
+    XScalarSelectedContentType,
+], { typeName: 'RequestBodyObject' });

package/dist/openapi/3.1/response.d.ts

@@ -0,0 +1,16 @@
+export declare const response: import("@scalar/validation").ObjectSchema<{
+    description: import("@scalar/validation").StringSchema;
+    headers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+    content: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+        schema: import("@scalar/validation").OptionalSchema<import("@scalar/validation").Schema>;
+        example: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+        examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        encoding: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+            contentType: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            headers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        }>>>;
+    }>>>>;
+    links: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+}>;
+export declare const responsesObject: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>;
+//# sourceMappingURL=response.d.ts.map

package/dist/openapi/3.1/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/response.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;EAiBpB,CAAA;AAED,eAAO,MAAM,eAAe,2HAE1B,CAAA"}

package/dist/openapi/3.1/response.js

@@ -0,0 +1,15 @@
+import { lazy, object, optional, record, string } from '@scalar/validation';
+import { link } from '../../openapi/3.1/link.js';
+import { header, mediaType } from '../../openapi/3.1/media-type.js';
+import { recursiveRef } from '../../openapi/3.1/reference.js';
+export const response = object({
+    description: string({
+        typeComment: 'REQUIRED. A description of the response. CommonMark syntax MAY be used for rich text representation.',
+    }),
+    headers: optional(record(string(), recursiveRef(lazy(() => header)), { typeName: 'ResponseHeaders' })),
+    content: optional(record(string(), lazy(() => mediaType), { typeName: 'ResponseContent' })),
+    links: optional(record(string(), recursiveRef(lazy(() => link)), { typeName: 'ResponseLinks' })),
+}, { typeName: 'ResponseObject' });
+export const responsesObject = record(string(), recursiveRef(lazy(() => response)), {
+    typeName: 'ResponsesObject',
+});

package/dist/openapi/3.1/schema.d.ts

@@ -0,0 +1,3 @@
+import { type Schema } from '@scalar/validation';
+export declare const schema: Schema;
+//# sourceMappingURL=schema.d.ts.map

package/dist/openapi/3.1/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AAqI3B,eAAO,MAAM,MAAM,EAAE,MAOpB,CAAA"}