@scalar/schemas 0.2.0 → 0.3.0

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"}

package/dist/openapi/3.1/schema.js

@@ -0,0 +1,100 @@
+import { any, array, boolean, intersection, lazy, literal, number, object, optional, record, string, union, } from '@scalar/validation';
+import { XInternal, XScalarIgnore, XTags } from '../../extensions/document/index.js';
+import { XAdditionalPropertiesName, XEnumDescriptions, XEnumVarNames, XExamples, XVariable } from '../../extensions/schema/index.js';
+import { discriminatorObject } from '../../openapi/3.1/discriminator.js';
+import { externalDocs } from '../../openapi/3.1/external-docs.js';
+import { normalRef } from '../../openapi/3.1/reference.js';
+import { xml } from '../../openapi/3.1/xml.js';
+const schemaExtensionObjects = [
+    XScalarIgnore,
+    XInternal,
+    XVariable,
+    XExamples,
+    XEnumDescriptions,
+    XEnumVarNames,
+    XAdditionalPropertiesName,
+    XTags,
+];
+const coreSchemaProperties = object({
+    name: optional(string({ typeComment: 'Schema name (extension).' })),
+    title: optional(string({ typeComment: 'A title for the schema.' })),
+    description: optional(string({ typeComment: 'A description of the schema.' })),
+    default: optional(any({ typeComment: 'Default value for the schema.' })),
+    enum: optional(array(any(), { typeComment: 'Array of allowed values.', typeName: 'JsonSchemaEnum' })),
+    const: optional(any({ typeComment: 'Constant value that must match exactly.' })),
+    contentMediaType: optional(string({ typeComment: 'Media type for content validation.' })),
+    contentEncoding: optional(string({ typeComment: 'Content encoding.' })),
+    contentSchema: optional(normalRef(lazy(() => schema))),
+    deprecated: optional(boolean({ typeComment: 'Whether the schema is deprecated.' })),
+    discriminator: optional(discriminatorObject),
+    readOnly: optional(boolean({ typeComment: 'Whether the schema is read-only.' })),
+    writeOnly: optional(boolean({ typeComment: 'Whether the schema is write-only.' })),
+    xml: optional(xml),
+    externalDocs: optional(externalDocs),
+    example: optional(any({
+        typeComment: 'A free-form field to include an example of an instance for this schema. Deprecated in favor of the JSON Schema examples keyword.',
+    })),
+    examples: optional(array(any(), {
+        typeComment: 'An array of examples of valid instances for this schema. This keyword follows the JSON Schema Draft 2020-12 specification.',
+        typeName: 'SchemaExamplesArray',
+    })),
+    allOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectAllOf' })),
+    oneOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectOneOf' })),
+    anyOf: optional(array(normalRef(lazy(() => schema)), { typeName: 'SchemaObjectAnyOf' })),
+    not: optional(normalRef(lazy(() => schema))),
+});
+const numericSchema = object({
+    type: union([literal('number'), literal('integer')]),
+    format: optional(string({ typeComment: 'Different subtypes.' })),
+    multipleOf: optional(number({ typeComment: 'Number must be a multiple of this value.' })),
+    maximum: optional(number({ typeComment: 'Maximum value (inclusive).' })),
+    exclusiveMaximum: optional(number({ typeComment: 'Maximum value (exclusive).' })),
+    minimum: optional(number({ typeComment: 'Minimum value (inclusive).' })),
+    exclusiveMinimum: optional(number({ typeComment: 'Minimum value (exclusive).' })),
+}, { typeName: 'NumberSchemaObject' });
+const stringSchema = object({
+    type: literal('string'),
+    format: optional(string({ typeComment: 'Different subtypes.' })),
+    maxLength: optional(number({ typeComment: 'Maximum string length.' })),
+    minLength: optional(number({ typeComment: 'Minimum string length.' })),
+    pattern: optional(string({ typeComment: 'Regular expression pattern.' })),
+}, { typeName: 'StringSchemaObject' });
+const objectSchema = object({
+    type: literal('object'),
+    maxProperties: optional(number({ typeComment: 'Maximum number of properties.' })),
+    minProperties: optional(number({ typeComment: 'Minimum number of properties.' })),
+    properties: optional(record(string(), normalRef(lazy(() => schema)), { typeName: 'SchemaObjectProperties' })),
+    required: optional(array(string(), { typeName: 'SchemaObjectRequired' })),
+    additionalProperties: optional(union([normalRef(lazy(() => schema)), object({}), boolean()], {
+        typeName: 'SchemaObjectAdditionalProperties',
+    })),
+    patternProperties: optional(record(string(), normalRef(lazy(() => schema)), { typeName: 'SchemaObjectPatternProperties' })),
+    propertyNames: optional(normalRef(lazy(() => schema))),
+}, { typeName: 'ObjectSchemaObject' });
+const arraySchema = object({
+    type: literal('array'),
+    maxItems: optional(number({ typeComment: 'Maximum number of items in array.' })),
+    minItems: optional(number({ typeComment: 'Minimum number of items in array.' })),
+    uniqueItems: optional(boolean({ typeComment: 'Whether array items must be unique.' })),
+    items: optional(normalRef(lazy(() => schema))),
+    prefixItems: optional(array(normalRef(lazy(() => schema)), { typeComment: 'Schema for tuple validation.' })),
+}, { typeName: 'ArraySchemaObject' });
+const schemaTypeMulti = union([
+    literal('null'),
+    literal('boolean'),
+    literal('string'),
+    literal('number'),
+    literal('integer'),
+    literal('object'),
+    literal('array'),
+], { typeName: 'SchemaObjectMultiTypeKeywords' });
+const otherTypeSchema = object({
+    type: union([literal('null'), literal('boolean'), array(schemaTypeMulti)], {
+        typeName: 'SchemaObjectOtherTypeKeyword',
+    }),
+}, { typeName: 'MultiTypeSchemaObject' });
+export const schema = intersection([
+    coreSchemaProperties,
+    ...schemaExtensionObjects,
+    union([otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema, object({})]),
+], { typeName: 'SchemaObject' });

package/dist/openapi/3.1/security-requirement.d.ts

@@ -0,0 +1,2 @@
+export declare const securityRequirement: import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+//# sourceMappingURL=security-requirement.d.ts.map

package/dist/openapi/3.1/security-requirement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-requirement.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/security-requirement.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,2KAI9B,CAAA"}

package/dist/openapi/3.1/security-requirement.js

@@ -0,0 +1,5 @@
+import { array, record, string } from '@scalar/validation';
+export const securityRequirement = record(string(), array(string()), {
+    typeName: 'SecurityRequirementObject',
+    typeComment: 'Lists the required security schemes to execute this operation. An empty object ({}) indicates anonymous access is supported.',
+});