@scalar/oas-utils 0.11.1 → 0.13.0

package/dist/entities/environment/environment.js

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-export const environmentSchema = z.object({
-    uid: z.string().brand(),
-    name: z.string().optional().default('Default Environment'),
-    color: z.string().optional().default('#FFFFFF'),
-    value: z.string().default(''),
-    isDefault: z.boolean().optional(),
-});

package/dist/entities/environment/index.d.ts

@@ -1,2 +0,0 @@
-export { type Environment, type EnvironmentPayload, environmentSchema } from './environment.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/entities/environment/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/environment/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA"}

package/dist/entities/environment/index.js

@@ -1 +0,0 @@
-export { environmentSchema } from './environment.js';

package/dist/entities/hotkeys/hotkeys.d.ts

@@ -1,15 +0,0 @@
-/**
- * Array of all of the events that we support
- */
-export declare const HOTKEY_EVENT_NAMES: readonly ["addTopNav", "closeModal", "closeTopNav", "createNew", "executeRequest", "focusAddressBar", "focusRequestSearch", "jumpToLastTab", "jumpToTab", "navigateSearchResultsDown", "navigateSearchResultsUp", "navigateTopNavLeft", "navigateTopNavRight", "openCommandPalette", "selectSearchResult", "toggleSidebar"];
-export type HotkeyEventName = (typeof HOTKEY_EVENT_NAMES)[number];
-/**
- * Array of all of the hotkeys that we support
- *
- * Space is a special case because its actually ' ' but we name it space here and will handle it separately
- * If you need more
- * @see https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
- */
-export declare const KEYDOWN_KEYS: readonly ["Space", "Backspace", "Tab", "Enter", "Escape", "ArrowDown", "ArrowLeft", "ArrowRight", "ArrowUp", "End", "Home", "PageDown", "PageUp", "Delete", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "+", "-", ".", "/", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", ";", "=", ",", "-", ".", "/", "`", "[", "\\", "]", ""];
-export type KeydownKey = (typeof KEYDOWN_KEYS)[number];
-//# sourceMappingURL=hotkeys.d.ts.map

package/dist/entities/hotkeys/hotkeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hotkeys.d.ts","sourceRoot":"","sources":["../../../src/entities/hotkeys/hotkeys.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,kBAAkB,6TAiBrB,CAAA;AACV,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjE;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,8hBAyFf,CAAA;AACV,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/entities/hotkeys/hotkeys.js

@@ -1,118 +0,0 @@
-/**
- * Array of all of the events that we support
- */
-export const HOTKEY_EVENT_NAMES = [
-    'addTopNav',
-    'closeModal',
-    'closeTopNav',
-    'createNew',
-    'executeRequest',
-    'focusAddressBar',
-    'focusRequestSearch',
-    'jumpToLastTab',
-    'jumpToTab',
-    'navigateSearchResultsDown',
-    'navigateSearchResultsUp',
-    'navigateTopNavLeft',
-    'navigateTopNavRight',
-    'openCommandPalette',
-    'selectSearchResult',
-    'toggleSidebar',
-];
-/**
- * Array of all of the hotkeys that we support
- *
- * Space is a special case because its actually ' ' but we name it space here and will handle it separately
- * If you need more
- * @see https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
- */
-export const KEYDOWN_KEYS = [
-    'Space',
-    'Backspace',
-    'Tab',
-    'Enter',
-    'Escape',
-    'ArrowDown',
-    'ArrowLeft',
-    'ArrowRight',
-    'ArrowUp',
-    'End',
-    'Home',
-    'PageDown',
-    'PageUp',
-    'Delete',
-    '0',
-    '1',
-    '2',
-    '3',
-    '4',
-    '5',
-    '6',
-    '7',
-    '8',
-    '9',
-    'a',
-    'b',
-    'c',
-    'd',
-    'e',
-    'f',
-    'g',
-    'h',
-    'i',
-    'j',
-    'k',
-    'l',
-    'm',
-    'n',
-    'o',
-    'p',
-    'q',
-    'r',
-    's',
-    't',
-    'u',
-    'v',
-    'w',
-    'x',
-    'y',
-    'z',
-    '0',
-    '1',
-    '2',
-    '3',
-    '4',
-    '5',
-    '6',
-    '7',
-    '8',
-    '9',
-    '*',
-    '+',
-    '-',
-    '.',
-    '/',
-    'F1',
-    'F2',
-    'F3',
-    'F4',
-    'F5',
-    'F6',
-    'F7',
-    'F8',
-    'F9',
-    'F10',
-    'F11',
-    'F12',
-    ';',
-    '=',
-    ',',
-    '-',
-    '.',
-    '/',
-    '`',
-    '[',
-    '\\',
-    ']',
-    '',
-];

package/dist/entities/hotkeys/index.d.ts

@@ -1,2 +0,0 @@
-export { type HotkeyEventName, type KeydownKey, HOTKEY_EVENT_NAMES, KEYDOWN_KEYS } from './hotkeys.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/entities/hotkeys/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/hotkeys/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA"}

package/dist/entities/hotkeys/index.js

@@ -1 +0,0 @@
-export { HOTKEY_EVENT_NAMES, KEYDOWN_KEYS } from './hotkeys.js';

package/dist/entities/shared/index.d.ts

@@ -1,2 +0,0 @@
-export { type SelectedSecuritySchemeUids, selectedSecuritySchemeUidSchema, } from './utility.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/entities/shared/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/shared/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,+BAA+B,GAChC,MAAM,WAAW,CAAA"}

package/dist/entities/shared/index.js

@@ -1 +0,0 @@
-export { selectedSecuritySchemeUidSchema, } from './utility.js';

package/dist/entities/shared/utility.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-/** Schema for selectedSecuritySchemeUids */
-export declare const selectedSecuritySchemeUidSchema: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "securityScheme", "out">, z.ZodArray<z.core.$ZodBranded<z.ZodString, "securityScheme", "out">>]>>>;
-export type SelectedSecuritySchemeUids = z.infer<typeof selectedSecuritySchemeUidSchema>;
-//# sourceMappingURL=utility.d.ts.map

package/dist/entities/shared/utility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../../../src/entities/shared/utility.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,4CAA4C;AAC5C,eAAO,MAAM,+BAA+B,iLAM9B,CAAA;AAEd,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

package/dist/entities/shared/utility.js

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-/** Schema for selectedSecuritySchemeUids */
-export const selectedSecuritySchemeUidSchema = z
-    .union([
-    z.string().brand(),
-    z.string().brand().array(),
-])
-    .array()
-    .default([]);

package/dist/entities/spec/collection.d.ts

@@ -1,133 +0,0 @@
-import { z } from 'zod';
-export declare const collectionSchema: z.ZodObject<{
-    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"collection">>>;
-    openapi: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"3.0.0">, z.ZodLiteral<"3.1.0">, z.ZodLiteral<"4.0.0">]>>>;
-    jsonSchemaDialect: z.ZodOptional<z.ZodString>;
-    info: z.ZodCatch<z.ZodPipe<z.ZodObject<{
-        title: z.ZodCatch<z.ZodString>;
-        summary: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        description: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        termsOfService: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        contact: z.ZodCatch<z.ZodOptional<z.ZodPipe<z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            url: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-            email: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        }, z.core.$strip>, z.ZodTransform<{
-            name?: string | undefined;
-            url?: string | undefined;
-            email?: string | undefined;
-        }, {
-            name?: string | undefined;
-            url?: string | undefined;
-            email?: string | undefined;
-        }>>>>;
-        license: z.ZodCatch<z.ZodOptional<z.ZodPipe<z.ZodObject<{
-            name: z.ZodCatch<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
-            identifier: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-            url: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        }, z.core.$strip>, z.ZodTransform<{
-            name?: string | null | undefined;
-            identifier?: string | undefined;
-            url?: string | undefined;
-        }, {
-            name?: string | null | undefined;
-            identifier?: string | undefined;
-            url?: string | undefined;
-        }>>>>;
-        version: z.ZodCatch<z.ZodString>;
-        'x-scalar-sdk-installation': z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodObject<{
-            lang: z.ZodString;
-            source: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-            description: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        }, z.core.$strip>>>>;
-    }, z.core.$strip>, z.ZodTransform<{
-        title: string;
-        version: string;
-        summary?: string | undefined;
-        description?: string | undefined;
-        termsOfService?: string | undefined;
-        contact?: {
-            name?: string | undefined;
-            url?: string | undefined;
-            email?: string | undefined;
-        } | undefined;
-        license?: {
-            name?: string | null | undefined;
-            identifier?: string | undefined;
-            url?: string | undefined;
-        } | undefined;
-        'x-scalar-sdk-installation'?: {
-            lang: string;
-            source?: string | undefined;
-            description?: string | undefined;
-        }[] | undefined;
-    }, {
-        title: string;
-        version: string;
-        summary?: string | undefined;
-        description?: string | undefined;
-        termsOfService?: string | undefined;
-        contact?: {
-            name?: string | undefined;
-            url?: string | undefined;
-            email?: string | undefined;
-        } | undefined;
-        license?: {
-            name?: string | null | undefined;
-            identifier?: string | undefined;
-            url?: string | undefined;
-        } | undefined;
-        'x-scalar-sdk-installation'?: {
-            lang: string;
-            source?: string | undefined;
-            description?: string | undefined;
-        }[] | undefined;
-    }>>>;
-    security: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>>>>>;
-    externalDocs: z.ZodCatch<z.ZodOptional<z.ZodPipe<z.ZodObject<{
-        description: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-        url: z.ZodString;
-    }, z.core.$strip>, z.ZodTransform<{
-        url: string;
-        description?: string | undefined;
-    }, {
-        url: string;
-        description?: string | undefined;
-    }>>>>;
-    components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    webhooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    'x-scalar-icon': z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    'x-scalar-active-environment': z.ZodOptional<z.ZodString>;
-    'x-scalar-environments': z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        color: z.ZodOptional<z.ZodString>;
-        variables: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            default: z.ZodDefault<z.ZodString>;
-        }, z.core.$strip>, z.ZodString]>>;
-    }, z.core.$strip>>>;
-    'x-scalar-secrets': z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        example: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    uid: z.core.$ZodBranded<z.ZodDefault<z.ZodString>, "collection", "out">;
-    securitySchemes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    selectedSecuritySchemeUids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "securityScheme", "out">, z.ZodArray<z.core.$ZodBranded<z.ZodString, "securityScheme", "out">>]>>>;
-    selectedServerUid: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "server", "out">>;
-    servers: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "server", "out">>>;
-    requests: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "operation", "out">>>;
-    tags: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "tag", "out">>>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "operation", "out">, z.core.$ZodBranded<z.ZodString, "tag", "out">]>>>;
-    documentUrl: z.ZodOptional<z.ZodString>;
-    watchMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    integration: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    useCollectionSecurity: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    watchModeStatus: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        IDLE: "IDLE";
-        WATCHING: "WATCHING";
-        ERROR: "ERROR";
-    }>>>;
-}, z.core.$strip>;
-export type Collection = z.infer<typeof collectionSchema>;
-export type CollectionPayload = z.input<typeof collectionSchema>;
-//# sourceMappingURL=collection.d.ts.map

package/dist/entities/spec/collection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/collection.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiGvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsD,CAAA;AACnF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/entities/spec/collection.js

@@ -1,95 +0,0 @@
-import { oasSecurityRequirementSchema } from '@scalar/types/entities';
-import { nanoidSchema } from '@scalar/types/utils';
-import { z } from 'zod';
-import { selectedSecuritySchemeUidSchema } from '../../entities/shared/utility.js';
-import { xScalarEnvironmentsSchema } from '../../entities/spec/x-scalar-environments.js';
-import { xScalarSecretsSchema } from '../../entities/spec/x-scalar-secrets.js';
-import { oasExternalDocumentationSchema, oasInfoSchema } from './spec-objects.js';
-const oasCollectionSchema = z.object({
-    /**
-     * @deprecated
-     * Needs to be remove as it is not a spec property
-     */
-    'type': z.literal('collection').optional().default('collection'),
-    'openapi': z
-        .union([z.string(), z.literal('3.0.0'), z.literal('3.1.0'), z.literal('4.0.0')])
-        .optional()
-        .default('3.1.0'),
-    'jsonSchemaDialect': z.string().optional(),
-    'info': oasInfoSchema.catch({
-        title: 'API',
-        version: '1.0',
-    }),
-    /**
-     * 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.
-     * Individual operations can override this definition. To make security optional, an empty
-     * security requirement ({}) can be included in the array.
-     */
-    'security': z.array(oasSecurityRequirementSchema).optional().default([]),
-    'externalDocs': oasExternalDocumentationSchema.optional().catch(undefined),
-    /** TODO: Type these */
-    'components': z.record(z.string(), z.unknown()).optional(),
-    /** TODO: Type these */
-    'webhooks': z.record(z.string(), z.unknown()).optional(),
-    /** A custom icon representing the collection */
-    'x-scalar-icon': z.string().optional().default('interface-content-folder'),
-    'x-scalar-active-environment': z.string().optional(),
-    'x-scalar-environments': xScalarEnvironmentsSchema.optional(),
-    'x-scalar-secrets': xScalarSecretsSchema.optional(),
-    // These properties will be stripped out and mapped back as id lists
-    // servers
-    // paths/**
-    // servers
-    // tags
-    // security
-});
-const extendedCollectionSchema = z.object({
-    uid: nanoidSchema.brand(),
-    /** A list of security schemes UIDs associated with the collection */
-    securitySchemes: z.string().array().default([]),
-    /** List of currently selected security scheme UIDs, these can be overridden per request */
-    selectedSecuritySchemeUids: selectedSecuritySchemeUidSchema,
-    /** The currently selected server */
-    selectedServerUid: z.string().brand().optional(),
-    /** UIDs which refer to servers on the workspace base */
-    servers: z.string().brand().array().default([]),
-    /** Request UIDs associated with a collection */
-    requests: z.string().brand().array().default([]),
-    /** Tag UIDs associated with the collection */
-    tags: z.string().brand().array().default([]),
-    /** List of requests without tags and top level tag "folders" */
-    children: z
-        .union([z.string().brand(), z.string().brand()])
-        .array()
-        .default([]),
-    /**
-     * A link to where this document is stored
-     *
-     * - Used for watch mode
-     * - Possibly useful for Git sync down the line
-     */
-    documentUrl: z.string().optional(),
-    /**
-     * Enables polling of OpenAPI document urls
-     *
-     * @remarks Only effective when `documentUrl` is set
-     */
-    watchMode: z.boolean().optional().default(false),
-    /** Keeps track of which integration is associated with the specific collection */
-    integration: z.string().nullable().optional(),
-    /**
-     * Selected authentication will be set at the collection level instead of the request level
-     *
-     * @default false
-     */
-    useCollectionSecurity: z.boolean().optional().default(false),
-    /**
-     * Status of the watcher from above
-     *
-     * @defaults to idle for all collections, doesn't mean that it can watch for changes
-     */
-    watchModeStatus: z.enum(['IDLE', 'WATCHING', 'ERROR']).optional().default('IDLE'),
-});
-export const collectionSchema = oasCollectionSchema.merge(extendedCollectionSchema);

package/dist/entities/spec/index.d.ts

@@ -1,12 +0,0 @@
-/** Re-exported here for ease of use but we should use the other ones directly */
-export { type Oauth2Flow, type Oauth2FlowPayload, type SecuritySchemaHttp, type SecuritySchemaOpenId, type SecurityScheme, type SecuritySchemeApiKey, type SecuritySchemeOauth2, type SecuritySchemeOauth2Payload, type SecuritySchemePayload, oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeSchema, } from '@scalar/types/entities';
-export { type Collection, type CollectionPayload, collectionSchema } from './collection.js';
-export { type Operation, type OperationPayload, operationSchema, } from './operation.js';
-export { type RequestParameter, type RequestParameterPayload, oasParameterSchema } from './parameters.js';
-export { type RequestExample, type RequestExampleParameter, createExampleFromRequest, requestExampleParametersSchema, requestExampleSchema, } from './request-examples.js';
-export { type Request, type RequestEvent, type RequestMethod, type RequestPayload, type ResponseInstance, requestSchema, } from './requests.js';
-export type { PostResponseScript, PostResponseScripts, } from './requests.ts';
-export { type Server, type ServerPayload, serverSchema } from './server.js';
-export { type Tag, type TagPayload, oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, tagSchema, } from './spec-objects.js';
-export { type XScalarEnvironment, type XScalarEnvironments, xScalarEnvironmentsSchema, } from './x-scalar-environments.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/entities/spec/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/index.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,4BAA4B,EAC5B,uBAAuB,EACvB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACxF,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACtG,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,wBAAwB,EACxB,8BAA8B,EAC9B,oBAAoB,GACrB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,aAAa,GACd,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACxE,OAAO,EACL,KAAK,GAAG,EACR,KAAK,UAAU,EACf,gBAAgB,EAChB,8BAA8B,EAC9B,aAAa,EACb,gBAAgB,EAChB,SAAS,GACV,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAA"}

package/dist/entities/spec/index.js

@@ -1,10 +0,0 @@
-/** Re-exported here for ease of use but we should use the other ones directly */
-export { oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeSchema, } from '@scalar/types/entities';
-export { collectionSchema } from './collection.js';
-export { operationSchema, } from './operation.js';
-export { oasParameterSchema } from './parameters.js';
-export { createExampleFromRequest, requestExampleParametersSchema, requestExampleSchema, } from './request-examples.js';
-export { requestSchema, } from './requests.js';
-export { serverSchema } from './server.js';
-export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, tagSchema, } from './spec-objects.js';
-export { xScalarEnvironmentsSchema, } from './x-scalar-environments.js';

package/dist/entities/spec/operation.d.ts

@@ -1,99 +0,0 @@
-/**
- * Aliases Request to Operation which is closer to the spec,
- * also will not conflict with the builtin Request class
- */
-import { type RequestPayload, type Request as RequestType } from './requests.js';
-export type Operation = RequestType;
-export type OperationPayload = RequestPayload;
-export declare const operationSchema: import("zod").ZodObject<{
-    description: import("zod").ZodOptional<import("zod").ZodString>;
-    summary: import("zod").ZodOptional<import("zod").ZodString>;
-    externalDocs: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodObject<{
-        description: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        url: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-        url: string;
-        description?: string | undefined;
-    }, {
-        url: string;
-        description?: string | undefined;
-    }>>>;
-    'x-internal': import("zod").ZodOptional<import("zod").ZodBoolean>;
-    'x-scalar-ignore': import("zod").ZodOptional<import("zod").ZodBoolean>;
-    security: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>>>>;
-    tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    deprecated: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    operationId: import("zod").ZodOptional<import("zod").ZodString>;
-    requestBody: import("zod").ZodOptional<import("zod").ZodAny>;
-    parameters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        in: import("zod").ZodEnum<{
-            cookie: "cookie";
-            path: "path";
-            query: "query";
-            header: "header";
-        }>;
-        name: import("zod").ZodString;
-        description: import("zod").ZodOptional<import("zod").ZodString>;
-        required: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-        deprecated: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-        schema: import("zod").ZodOptional<import("zod").ZodUnknown>;
-        content: import("zod").ZodOptional<import("zod").ZodUnknown>;
-        style: import("zod").ZodOptional<import("zod").ZodEnum<{
-            matrix: "matrix";
-            label: "label";
-            form: "form";
-            simple: "simple";
-            spaceDelimited: "spaceDelimited";
-            pipeDelimited: "pipeDelimited";
-            deepObject: "deepObject";
-        }>>;
-        explode: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        example: import("zod").ZodOptional<import("zod").ZodUnknown>;
-        examples: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
-            summary: import("zod").ZodOptional<import("zod").ZodString>;
-            externalValue: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>, import("zod").ZodArray<import("zod").ZodUnknown>]>>;
-    }, import("zod/v4/core").$strip>>>;
-    responses: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
-    callbacks: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>>>;
-    'x-codeSamples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        source: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>>>>;
-    'x-code-samples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        source: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>>>>;
-    'x-custom-examples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        source: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>>>>;
-    'x-scalar-stability': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodEnum<{
-        deprecated: import("@scalar/types/legacy").XScalarStability.Deprecated;
-        experimental: import("@scalar/types/legacy").XScalarStability.Experimental;
-        stable: import("@scalar/types/legacy").XScalarStability.Stable;
-    }>>>;
-    type: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"request">>>;
-    uid: import("zod/v4/core").$ZodBranded<import("zod").ZodDefault<import("zod").ZodString>, "operation", "out">;
-    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-    method: import("zod").ZodDefault<import("zod").ZodEnum<{
-        delete: "delete";
-        get: "get";
-        head: "head";
-        options: "options";
-        patch: "patch";
-        post: "post";
-        put: "put";
-        trace: "trace";
-    }>>;
-    servers: import("zod").ZodDefault<import("zod").ZodArray<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "server", "out">>>;
-    selectedServerUid: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "server", "out">>>>;
-    examples: import("zod").ZodDefault<import("zod").ZodArray<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "example", "out">>>;
-    selectedSecuritySchemeUids: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod/v4/core").$ZodBranded<import("zod").ZodString, "securityScheme", "out">, import("zod").ZodArray<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "securityScheme", "out">>]>>>;
-    'x-post-response': import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod/v4/core").$strip>;
-//# sourceMappingURL=operation.d.ts.map

package/dist/entities/spec/operation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/operation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,IAAI,WAAW,EAAiB,MAAM,YAAY,CAAA;AAE5F,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAC7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAgB,CAAA"}

package/dist/entities/spec/operation.js

@@ -1,6 +0,0 @@
-/**
- * Aliases Request to Operation which is closer to the spec,
- * also will not conflict with the builtin Request class
- */
-import { requestSchema } from './requests.js';
-export const operationSchema = requestSchema;

package/dist/entities/spec/parameters.d.ts

@@ -1,44 +0,0 @@
-import type { OpenAPIV3_1 } from '@scalar/openapi-types';
-import { z } from 'zod';
-import type { RequestExampleParameter } from './request-examples.js';
-export type ParameterContent = Record<string, {
-    schema?: OpenAPIV3_1.Document;
-    examples?: Record<string, RequestExampleParameter>;
-    example?: RequestExampleParameter;
-}>;
-/**
- * OpenAPI compliant parameters object
- */
-export declare const oasParameterSchema: z.ZodObject<{
-    in: z.ZodEnum<{
-        cookie: "cookie";
-        path: "path";
-        query: "query";
-        header: "header";
-    }>;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    schema: z.ZodOptional<z.ZodUnknown>;
-    content: z.ZodOptional<z.ZodUnknown>;
-    style: z.ZodOptional<z.ZodEnum<{
-        matrix: "matrix";
-        label: "label";
-        form: "form";
-        simple: "simple";
-        spaceDelimited: "spaceDelimited";
-        pipeDelimited: "pipeDelimited";
-        deepObject: "deepObject";
-    }>>;
-    explode: z.ZodOptional<z.ZodBoolean>;
-    example: z.ZodOptional<z.ZodUnknown>;
-    examples: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
-        value: z.ZodOptional<z.ZodUnknown>;
-        summary: z.ZodOptional<z.ZodString>;
-        externalValue: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>, z.ZodArray<z.ZodUnknown>]>>;
-}, z.core.$strip>;
-export type RequestParameter = z.infer<typeof oasParameterSchema>;
-export type RequestParameterPayload = z.input<typeof oasParameterSchema>;
-//# sourceMappingURL=parameters.d.ts.map

package/dist/entities/spec/parameters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAkBjE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN;IACE,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;IAClD,OAAO,CAAC,EAAE,uBAAuB,CAAA;CAClC,CACF,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BU,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACjE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}