@scalar/schemas 0.2.0 → 0.3.1

package/dist/openapi/3.1/components.js

@@ -0,0 +1,24 @@
+import { lazy, object, optional, record, string } from '@scalar/validation';
+import { callback } from '../../openapi/3.1/callback.js';
+import { example } from '../../openapi/3.1/example.js';
+import { link } from '../../openapi/3.1/link.js';
+import { header } from '../../openapi/3.1/media-type.js';
+import { parameter } from '../../openapi/3.1/parameter.js';
+import { pathItem } from '../../openapi/3.1/path-item.js';
+import { normalRef, recursiveRef } from '../../openapi/3.1/reference.js';
+import { requestBody } from '../../openapi/3.1/request-body.js';
+import { response } from '../../openapi/3.1/response.js';
+import { schema } from '../../openapi/3.1/schema.js';
+import { securityScheme } from '../../openapi/3.1/security-schemes.js';
+export const components = lazy(() => object({
+    schemas: optional(record(string(), normalRef(schema), { typeName: 'ComponentsSchemas' })),
+    responses: optional(record(string(), recursiveRef(lazy(() => response)), { typeName: 'ComponentsResponses' })),
+    parameters: optional(record(string(), recursiveRef(lazy(() => parameter)), { typeName: 'ComponentsParameters' })),
+    examples: optional(record(string(), recursiveRef(lazy(() => example)), { typeName: 'ComponentsExamples' })),
+    requestBodies: optional(record(string(), recursiveRef(lazy(() => requestBody)), { typeName: 'ComponentsRequestBodies' })),
+    headers: optional(record(string(), recursiveRef(lazy(() => header)), { typeName: 'ComponentsHeaders' })),
+    securitySchemes: optional(record(string(), recursiveRef(lazy(() => securityScheme)), { typeName: 'ComponentsSecuritySchemes' })),
+    links: optional(record(string(), recursiveRef(lazy(() => link)), { typeName: 'ComponentsLinks' })),
+    callbacks: optional(record(string(), recursiveRef(lazy(() => callback)), { typeName: 'ComponentsCallbacks' })),
+    pathItems: optional(record(string(), lazy(() => pathItem), { typeName: 'ComponentsPathItems' })),
+}, { typeName: 'ComponentsObject' }));

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

@@ -0,0 +1,6 @@
+export declare const contact: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    email: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=contact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/contact.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;EAYnB,CAAA"}

package/dist/openapi/3.1/contact.js

@@ -0,0 +1,8 @@
+import { object, optional, string } from '@scalar/validation';
+export const contact = object({
+    name: optional(string({ typeComment: 'The name of the contact.' })),
+    url: optional(string({ typeComment: 'The URI for the contact information. This MUST be in the form of a URI.' })),
+    email: optional(string({
+        typeComment: 'The email address of the contact person/organization. This MUST be in the form of an email address.',
+    })),
+}, { typeName: 'ContactObject' });

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

@@ -0,0 +1,5 @@
+export declare const discriminatorObject: import("@scalar/validation").ObjectSchema<{
+    propertyName: import("@scalar/validation").StringSchema;
+    mapping: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").StringSchema>>;
+}>;
+//# sourceMappingURL=discriminator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/discriminator.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;EAa/B,CAAA"}

package/dist/openapi/3.1/discriminator.js

@@ -0,0 +1,9 @@
+import { object, optional, record, string } from '@scalar/validation';
+export const discriminatorObject = object({
+    propertyName: string({
+        typeComment: 'REQUIRED. The name of the property in the payload that will hold the discriminating value. This property SHOULD be required in the payload schema, as the behavior when the property is absent is undefined.',
+    }),
+    mapping: optional(record(string(), string(), {
+        typeComment: 'An object to hold mappings between payload values and schema names or URI references.',
+    })),
+}, { typeName: 'DiscriminatorObject' });

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

@@ -0,0 +1,201 @@
+export declare const openApiSchema: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    openapi: import("@scalar/validation").StringSchema;
+    info: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        title: import("@scalar/validation").StringSchema;
+        version: import("@scalar/validation").StringSchema;
+        summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        termsOfService: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        contact: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            email: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>;
+        license: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").StringSchema;
+            identifier: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            lang: import("@scalar/validation").StringSchema;
+            source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+    }>]>;
+    jsonSchemaDialect: import("@scalar/validation").OptionalSchema<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>;
+        }>>>;
+    }>>>;
+    paths: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, 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>>;
+    }>>>;
+    webhooks: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, 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>>;
+    }>>>;
+    components: import("@scalar/validation").OptionalSchema<import("@scalar/validation").LazySchema<() => import("@scalar/validation").ObjectSchema<{
+        schemas: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        responses: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        parameters: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        requestBodies: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        headers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        securitySchemes: 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>>;
+        callbacks: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").Schema>>;
+        pathItems: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").LazySchema<() => 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>>;
+        }>>>>;
+    }>>>;
+    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>>>>;
+    tags: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        name: 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>;
+        }>>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-displayName': 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-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<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>;
+    }>>;
+}>, import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    'x-original-oas-version': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-navigation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-original-source-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-tagGroups': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        tags: import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>]>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-environments': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        color: import("@scalar/validation").StringSchema;
+        variables: import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").StringSchema;
+            value: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+                description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+                default: import("@scalar/validation").StringSchema;
+            }>, import("@scalar/validation").StringSchema]>;
+        }>>;
+    }>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-selected-server': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-icon': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-cookies': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        value: import("@scalar/validation").StringSchema;
+        domain: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        path: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        isDisabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-original-document-hash': import("@scalar/validation").StringSchema;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-is-dirty': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-active-environment': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-watch-mode': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-registry-meta': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        namespace: import("@scalar/validation").StringSchema;
+        slug: import("@scalar/validation").StringSchema;
+        version: import("@scalar/validation").StringSchema;
+        commitHash: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        conflictCheckedAgainstHash: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        hasConflict: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-pre-request': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-post-response': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>]>]>;
+//# sourceMappingURL=document.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/document.ts"],"names":[],"mappings":"AA2GA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGxB,CAAA"}

package/dist/openapi/3.1/document.js

@@ -0,0 +1,67 @@
+import { array, intersection, object, optional, record, string } from '@scalar/validation';
+import { XOriginalOasVersion, XScalarEnvironments, XScalarIcon, XScalarIsDirty, XScalarNavigation, XScalarOriginalDocumentHash, XScalarOriginalSourceUrl, XScalarRegistryMeta, XScalarWatchMode, } from '../../extensions/document/index.js';
+import { XPostResponse, XPreRequest, XScalarActiveEnvironment, XScalarCookies, XScalarOrder, } from '../../extensions/general/index.js';
+import { XScalarSelectedServer } from '../../extensions/server/index.js';
+import { XTagGroups } from '../../extensions/tag/index.js';
+import { components } from '../../openapi/3.1/components.js';
+import { externalDocs } from '../../openapi/3.1/external-docs.js';
+import { info } from '../../openapi/3.1/info.js';
+import { pathItem } from '../../openapi/3.1/path-item.js';
+import { securityRequirement } from '../../openapi/3.1/security-requirement.js';
+import { server } from '../../openapi/3.1/server.js';
+import { tag } from '../../openapi/3.1/tag.js';
+const openapiExtensions = intersection([
+    XOriginalOasVersion,
+    XScalarNavigation,
+    XScalarOriginalSourceUrl,
+    XTagGroups,
+    XScalarEnvironments,
+    XScalarSelectedServer,
+    XScalarIcon,
+    XScalarOrder,
+    XScalarCookies,
+    XScalarOriginalDocumentHash,
+    XScalarIsDirty,
+    XScalarActiveEnvironment,
+    XScalarWatchMode,
+    XScalarRegistryMeta,
+    XPreRequest,
+    XPostResponse,
+], {
+    typeName: 'OpenApiExtensions',
+    typeComment: 'OpenAPI extensions shared by OpenAPI and AsyncAPI documents.',
+});
+const openApiDocumentCore = object({
+    openapi: string({
+        typeComment: 'REQUIRED. This string MUST be the version number of the OpenAPI Specification that the OpenAPI Document uses. The openapi field SHOULD be used by tooling to interpret the OpenAPI Document. This is not related to the API info.version string.',
+    }),
+    info,
+    jsonSchemaDialect: optional(string({
+        typeComment: 'The default value for the $schema keyword within Schema Objects contained within this OAS document. This MUST be in the form of a URI.',
+    })),
+    servers: optional(array(server, {
+        typeComment: 'An array of Server Objects, which provide connectivity information to a target server. If the servers field is not provided, or is an empty array, the default value would be a Server Object with a url value of /.',
+        typeName: 'OpenApiServers',
+    })),
+    paths: optional(record(string(), pathItem, {
+        typeComment: 'The available paths and operations for the API.',
+        typeName: 'PathsObject',
+    })),
+    webhooks: optional(record(string(), pathItem, {
+        typeComment: 'The incoming webhooks that MAY be received as part of this API and that the API consumer MAY choose to implement.',
+        typeName: 'WebhooksObject',
+    })),
+    components: optional(components),
+    security: optional(array(securityRequirement, {
+        typeComment: 'A declaration of which security mechanisms can be used across the API. The list of values includes alternative Security Requirement Objects that can be used. Only one of the Security Requirement Objects need to be satisfied to authorize a request.',
+        typeName: 'OpenApiSecurity',
+    })),
+    tags: optional(array(tag, {
+        typeComment: 'A list of tags used by the OpenAPI Description with additional metadata. The order of the tags can be used to reflect on their order by the parsing tools.',
+    })),
+    externalDocs: optional(externalDocs),
+}, { typeName: 'OpenApiDocumentCore' });
+export const openApiSchema = intersection([openApiDocumentCore, openapiExtensions], {
+    typeName: 'OpenApiDocument',
+    typeComment: 'Root OpenAPI 3.1 document including Scalar workspace extensions (OpenApiExtensionsSchema).',
+});

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

@@ -0,0 +1,9 @@
+export declare const example: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    value: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    externalValue: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-disabled': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>]>;
+//# sourceMappingURL=example.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/example.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO;;;;;;;IAwBnB,CAAA"}

package/dist/openapi/3.1/example.js

@@ -0,0 +1,17 @@
+import { any, intersection, object, optional, string } from '@scalar/validation';
+import { XDisabled } from '../../extensions/example/index.js';
+export const example = intersection([
+    object({
+        summary: optional(string({ typeComment: 'Short description for the example.' })),
+        description: optional(string({
+            typeComment: 'Long description for the example. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        value: optional(any({
+            typeComment: 'Embedded literal example. The value field and externalValue field are mutually exclusive.',
+        })),
+        externalValue: optional(string({
+            typeComment: 'A URI that identifies the literal example. The value field and externalValue field are mutually exclusive.',
+        })),
+    }),
+    XDisabled,
+], { typeName: 'ExampleObject' });

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

@@ -0,0 +1,5 @@
+export declare const externalDocs: import("@scalar/validation").ObjectSchema<{
+    url: import("@scalar/validation").StringSchema;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=external-docs.d.ts.map

package/dist/openapi/3.1/external-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-docs.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/external-docs.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;EAaxB,CAAA"}

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

@@ -0,0 +1,9 @@
+import { object, optional, string } from '@scalar/validation';
+export const externalDocs = object({
+    url: string({
+        typeComment: 'REQUIRED. The URI for the target documentation. This MUST be in the form of a URI.',
+    }),
+    description: optional(string({
+        typeComment: 'A description of the target documentation. CommonMark syntax MAY be used for rich text representation.',
+    })),
+}, { typeName: 'ExternalDocumentationObject' });

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

@@ -0,0 +1,25 @@
+export { callback } from './callback.js';
+export { components } from './components.js';
+export { contact } from './contact.js';
+export { discriminatorObject } from './discriminator.js';
+export { openApiSchema } from './document.js';
+export { example } from './example.js';
+export { externalDocs } from './external-docs.js';
+export { info } from './info.js';
+export { license } from './license.js';
+export { link } from './link.js';
+export { encoding, header, mediaType } from './media-type.js';
+export { operation } from './operation.js';
+export { parameter } from './parameter.js';
+export { pathItem } from './path-item.js';
+export { normalRef, recursiveRef } from './reference.js';
+export { requestBody } from './request-body.js';
+export { response, responsesObject } from './response.js';
+export { schema } from './schema.js';
+export { securityRequirement } from './security-requirement.js';
+export { securityScheme } from './security-schemes.js';
+export { server } from './server.js';
+export { serverVariable } from './server-variable.js';
+export { tag } from './tag.js';
+export { xml } from './xml.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA"}

package/dist/openapi/3.1/index.js

@@ -0,0 +1,24 @@
+export { callback } from './callback.js';
+export { components } from './components.js';
+export { contact } from './contact.js';
+export { discriminatorObject } from './discriminator.js';
+export { openApiSchema } from './document.js';
+export { example } from './example.js';
+export { externalDocs } from './external-docs.js';
+export { info } from './info.js';
+export { license } from './license.js';
+export { link } from './link.js';
+export { encoding, header, mediaType } from './media-type.js';
+export { operation } from './operation.js';
+export { parameter } from './parameter.js';
+export { pathItem } from './path-item.js';
+export { normalRef, recursiveRef } from './reference.js';
+export { requestBody } from './request-body.js';
+export { response, responsesObject } from './response.js';
+export { schema } from './schema.js';
+export { securityRequirement } from './security-requirement.js';
+export { securityScheme } from './security-schemes.js';
+export { server } from './server.js';
+export { serverVariable } from './server-variable.js';
+export { tag } from './tag.js';
+export { xml } from './xml.js';

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

@@ -0,0 +1,24 @@
+export declare const info: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    title: import("@scalar/validation").StringSchema;
+    version: import("@scalar/validation").StringSchema;
+    summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    termsOfService: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    contact: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        email: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>;
+    license: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        identifier: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        lang: import("@scalar/validation").StringSchema;
+        source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>>;
+}>]>;
+//# sourceMappingURL=info.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/info.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;IAuBhB,CAAA"}

package/dist/openapi/3.1/info.js

@@ -0,0 +1,20 @@
+import { intersection, object, optional, string } from '@scalar/validation';
+import { XScalarSdkInstallation } from '../../extensions/document/index.js';
+import { contact } from '../../openapi/3.1/contact.js';
+import { license } from '../../openapi/3.1/license.js';
+export const info = intersection([
+    object({
+        title: string({ typeComment: 'REQUIRED. The title of the API.' }),
+        version: string({
+            typeComment: 'REQUIRED. The version of the OpenAPI Document (which is distinct from the OpenAPI Specification version or the version of the API being described or the version of the OpenAPI Description).',
+        }),
+        summary: optional(string({ typeComment: 'A short summary of the API.' })),
+        description: optional(string({
+            typeComment: 'A description of the API. CommonMark syntax MAY be used for rich text representation.',
+        })),
+        termsOfService: optional(string({ typeComment: 'A URI for the Terms of Service for the API. This MUST be in the form of a URI.' })),
+        contact: optional(contact),
+        license: optional(license),
+    }),
+    XScalarSdkInstallation,
+], { typeName: 'InfoObject' });

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

@@ -0,0 +1,6 @@
+export declare const license: import("@scalar/validation").ObjectSchema<{
+    name: import("@scalar/validation").StringSchema;
+    identifier: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>;
+//# sourceMappingURL=license.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"license.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/license.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;EAiBnB,CAAA"}

package/dist/openapi/3.1/license.js

@@ -0,0 +1,10 @@
+import { object, optional, string } from '@scalar/validation';
+export const license = object({
+    name: string({ typeComment: 'REQUIRED. The license name used for the API.' }),
+    identifier: optional(string({
+        typeComment: 'An SPDX license expression for the API. The identifier field is mutually exclusive of the url field.',
+    })),
+    url: optional(string({
+        typeComment: 'A URI for the license used for the API. This MUST be in the form of a URI. The url field is mutually exclusive of the identifier field.',
+    })),
+}, { typeName: 'LicenseObject' });

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

@@ -0,0 +1,17 @@
+export declare const link: import("@scalar/validation").ObjectSchema<{
+    operationRef: 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").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").AnySchema>>;
+    requestBody: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    server: import("@scalar/validation").OptionalSchema<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>;
+        }>>>;
+    }>>;
+}>;
+//# sourceMappingURL=link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/openapi/3.1/link.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;EAkChB,CAAA"}

package/dist/openapi/3.1/link.js

@@ -0,0 +1,21 @@
+import { any, object, optional, record, string } from '@scalar/validation';
+import { server } from '../../openapi/3.1/server.js';
+export const link = object({
+    operationRef: optional(string({
+        typeComment: 'A URI reference to an OAS operation. This field is mutually exclusive of the operationId field, and MUST point to an Operation Object.',
+    })),
+    operationId: optional(string({
+        typeComment: 'The name of an existing, resolvable OAS operation, as defined with a unique operationId. This field is mutually exclusive of the operationRef field.',
+    })),
+    parameters: optional(record(string(), any(), {
+        typeComment: 'A map representing parameters to pass to an operation as specified with operationId or identified via operationRef.',
+        typeName: 'LinkParameters',
+    })),
+    requestBody: optional(any({
+        typeComment: 'A literal value or {expression} to use as a request body when calling the target operation.',
+    })),
+    description: optional(string({
+        typeComment: 'A description of the link. CommonMark syntax MAY be used for rich text representation.',
+    })),
+    server: optional(server),
+}, { typeName: 'LinkObject' });

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

@@ -0,0 +1,16 @@
+import { type Schema } from '@scalar/validation';
+export declare const header: import("@scalar/validation").UnionSchema<readonly [import("@scalar/validation").IntersectionSchema<readonly Schema[]>, import("@scalar/validation").IntersectionSchema<readonly Schema[]>]>;
+export declare const encoding: 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, Schema>>;
+}>;
+export declare const mediaType: import("@scalar/validation").ObjectSchema<{
+    schema: import("@scalar/validation").OptionalSchema<Schema>;
+    example: import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+    examples: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, 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, Schema>>;
+    }>>>;
+}>;
+//# sourceMappingURL=media-type.d.ts.map