@scalar/oas-utils 0.11.1 → 0.12.0

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

package/dist/entities/spec/parameters.js

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-const parameterTypeSchema = z.enum(['path', 'query', 'header', 'cookie']);
-// not used but kept for consistency
-// export type ParamType = z.infer<typeof parameterTypeSchema>
-const parameterStyleSchema = z.enum([
-    'matrix',
-    'simple',
-    'form',
-    'label',
-    'spaceDelimited',
-    'pipeDelimited',
-    'deepObject',
-]);
-/**
- * OpenAPI compliant parameters object
- */
-export const oasParameterSchema = z.object({
-    in: parameterTypeSchema,
-    name: z.string(),
-    description: z.string().optional(),
-    /** Defaulted to false */
-    required: z.boolean().optional().default(false),
-    /** Defaulted to false */
-    deprecated: z.boolean().optional().default(false),
-    schema: z.unknown().optional(),
-    content: z.unknown().optional(),
-    /** Defaulted according to @url https://spec.openapis.org/oas/v3.1.0#parameter-object */
-    style: parameterStyleSchema.optional(),
-    explode: z.boolean().optional(),
-    example: z.unknown().optional(),
-    examples: z
-        .union([
-        z.record(z.string(), z.object({
-            value: z.unknown().optional(),
-            summary: z.string().optional(),
-            externalValue: z.string().optional(),
-        })),
-        z.array(z.unknown()),
-    ])
-        .optional(),
-});

package/dist/entities/spec/request-examples.d.ts

@@ -1,380 +0,0 @@
-import { z } from 'zod';
-import type { RequestParameter } from './parameters.js';
-import type { Request } from './requests.js';
-import type { Server } from './server.js';
-/**
- * TODO: Deprecate this.
- *
- * The request schema should be stored in the request and any
- * parameters should be validated against that
- */
-export declare const requestExampleParametersSchema: z.ZodPipe<z.ZodObject<{
-    key: z.ZodDefault<z.ZodString>;
-    value: z.ZodDefault<z.ZodCoercedString<unknown>>;
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    file: z.ZodOptional<z.ZodAny>;
-    description: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    examples: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-    type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    format: z.ZodOptional<z.ZodString>;
-    minimum: z.ZodOptional<z.ZodNumber>;
-    maximum: z.ZodOptional<z.ZodNumber>;
-    default: z.ZodOptional<z.ZodAny>;
-    nullable: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>, z.ZodTransform<{
-    key: string;
-    value: string;
-    enabled: boolean;
-    file?: any;
-    description?: string | undefined;
-    required?: boolean | undefined;
-    enum?: string[] | undefined;
-    examples?: any[] | undefined;
-    type?: string | string[] | undefined;
-    format?: string | undefined;
-    minimum?: number | undefined;
-    maximum?: number | undefined;
-    default?: any;
-    nullable?: boolean | undefined;
-}, {
-    key: string;
-    value: string;
-    enabled: boolean;
-    file?: any;
-    description?: string | undefined;
-    required?: boolean | undefined;
-    enum?: string[] | undefined;
-    examples?: any[] | undefined;
-    type?: string | string[] | undefined;
-    format?: string | undefined;
-    minimum?: number | undefined;
-    maximum?: number | undefined;
-    default?: any;
-    nullable?: boolean | undefined;
-}>>;
-/** Convert the array of parameters to an object keyed by the parameter name */
-export declare const parameterArrayToObject: (params: RequestExampleParameter[]) => Record<string, string>;
-/** Request examples - formerly known as instances - are "children" of requests */
-export type RequestExampleParameter = z.infer<typeof requestExampleParametersSchema>;
-export declare const requestExampleSchema: z.ZodObject<{
-    uid: z.core.$ZodBranded<z.ZodDefault<z.ZodString>, "example", "out">;
-    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"requestExample">>>;
-    requestUid: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "operation", "out">>;
-    name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    body: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        raw: z.ZodOptional<z.ZodObject<{
-            encoding: z.ZodEnum<{
-                xml: "xml";
-                json: "json";
-                html: "html";
-                text: "text";
-                javascript: "javascript";
-                yaml: "yaml";
-                edn: "edn";
-            }>;
-            value: z.ZodDefault<z.ZodString>;
-            mimeType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        formData: z.ZodOptional<z.ZodObject<{
-            encoding: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"form-data">, z.ZodLiteral<"urlencoded">]>>;
-            value: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
-                key: z.ZodDefault<z.ZodString>;
-                value: z.ZodDefault<z.ZodCoercedString<unknown>>;
-                enabled: z.ZodDefault<z.ZodBoolean>;
-                file: z.ZodOptional<z.ZodAny>;
-                description: z.ZodOptional<z.ZodString>;
-                required: z.ZodOptional<z.ZodBoolean>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                examples: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-                type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-                format: z.ZodOptional<z.ZodString>;
-                minimum: z.ZodOptional<z.ZodNumber>;
-                maximum: z.ZodOptional<z.ZodNumber>;
-                default: z.ZodOptional<z.ZodAny>;
-                nullable: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>, z.ZodTransform<{
-                key: string;
-                value: string;
-                enabled: boolean;
-                file?: any;
-                description?: string | undefined;
-                required?: boolean | undefined;
-                enum?: string[] | undefined;
-                examples?: any[] | undefined;
-                type?: string | string[] | undefined;
-                format?: string | undefined;
-                minimum?: number | undefined;
-                maximum?: number | undefined;
-                default?: any;
-                nullable?: boolean | undefined;
-            }, {
-                key: string;
-                value: string;
-                enabled: boolean;
-                file?: any;
-                description?: string | undefined;
-                required?: boolean | undefined;
-                enum?: string[] | undefined;
-                examples?: any[] | undefined;
-                type?: string | string[] | undefined;
-                format?: string | undefined;
-                minimum?: number | undefined;
-                maximum?: number | undefined;
-                default?: any;
-                nullable?: boolean | undefined;
-            }>>>>;
-        }, z.core.$strip>>;
-        binary: z.ZodOptional<z.ZodCustom<Blob, Blob>>;
-        activeBody: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"raw">, z.ZodLiteral<"formData">, z.ZodLiteral<"binary">]>>;
-    }, z.core.$strip>>>;
-    parameters: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        path: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
-            key: z.ZodDefault<z.ZodString>;
-            value: z.ZodDefault<z.ZodCoercedString<unknown>>;
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            file: z.ZodOptional<z.ZodAny>;
-            description: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            examples: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-            type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            format: z.ZodOptional<z.ZodString>;
-            minimum: z.ZodOptional<z.ZodNumber>;
-            maximum: z.ZodOptional<z.ZodNumber>;
-            default: z.ZodOptional<z.ZodAny>;
-            nullable: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>, z.ZodTransform<{
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }, {
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }>>>>;
-        query: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
-            key: z.ZodDefault<z.ZodString>;
-            value: z.ZodDefault<z.ZodCoercedString<unknown>>;
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            file: z.ZodOptional<z.ZodAny>;
-            description: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            examples: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-            type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            format: z.ZodOptional<z.ZodString>;
-            minimum: z.ZodOptional<z.ZodNumber>;
-            maximum: z.ZodOptional<z.ZodNumber>;
-            default: z.ZodOptional<z.ZodAny>;
-            nullable: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>, z.ZodTransform<{
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }, {
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }>>>>;
-        headers: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
-            key: z.ZodDefault<z.ZodString>;
-            value: z.ZodDefault<z.ZodCoercedString<unknown>>;
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            file: z.ZodOptional<z.ZodAny>;
-            description: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            examples: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-            type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            format: z.ZodOptional<z.ZodString>;
-            minimum: z.ZodOptional<z.ZodNumber>;
-            maximum: z.ZodOptional<z.ZodNumber>;
-            default: z.ZodOptional<z.ZodAny>;
-            nullable: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>, z.ZodTransform<{
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }, {
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }>>>>;
-        cookies: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodObject<{
-            key: z.ZodDefault<z.ZodString>;
-            value: z.ZodDefault<z.ZodCoercedString<unknown>>;
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            file: z.ZodOptional<z.ZodAny>;
-            description: z.ZodOptional<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            examples: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-            type: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            format: z.ZodOptional<z.ZodString>;
-            minimum: z.ZodOptional<z.ZodNumber>;
-            maximum: z.ZodOptional<z.ZodNumber>;
-            default: z.ZodOptional<z.ZodAny>;
-            nullable: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>, z.ZodTransform<{
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }, {
-            key: string;
-            value: string;
-            enabled: boolean;
-            file?: any;
-            description?: string | undefined;
-            required?: boolean | undefined;
-            enum?: string[] | undefined;
-            examples?: any[] | undefined;
-            type?: string | string[] | undefined;
-            format?: string | undefined;
-            minimum?: number | undefined;
-            maximum?: number | undefined;
-            default?: any;
-            nullable?: boolean | undefined;
-        }>>>>;
-    }, z.core.$strip>>>;
-    serverVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-}, z.core.$strip>;
-export type RequestExample = z.infer<typeof requestExampleSchema>;
-/** Schema for the OAS serialization of request examples */
-export declare const xScalarExampleSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    body: z.ZodOptional<z.ZodObject<{
-        encoding: z.ZodEnum<{
-            binary: "binary";
-            "application/json": "application/json";
-            "text/plain": "text/plain";
-            "text/html": "text/html";
-            "application/javascript": "application/javascript";
-            "application/xml": "application/xml";
-            "application/yaml": "application/yaml";
-            "application/edn": "application/edn";
-            "application/octet-stream": "application/octet-stream";
-            "application/x-www-form-urlencoded": "application/x-www-form-urlencoded";
-            "multipart/form-data": "multipart/form-data";
-        }>;
-        content: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodString]>;
-        file: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-            url: z.ZodString;
-            base64: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-    parameters: z.ZodObject<{
-        path: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        cookies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Convert a request example to the xScalar serialized format
- *
- * TODO: The base format should be migrated to align MUCH closer to the serialized format
- */
-export declare function convertExampleToXScalar(example: RequestExample): {
-    parameters: {
-        path?: Record<string, string> | undefined;
-        query?: Record<string, string> | undefined;
-        headers?: Record<string, string> | undefined;
-        cookies?: Record<string, string> | undefined;
-    };
-    name?: string | undefined;
-    body?: {
-        encoding: "binary" | "application/json" | "text/plain" | "text/html" | "application/javascript" | "application/xml" | "application/yaml" | "application/edn" | "application/octet-stream" | "application/x-www-form-urlencoded" | "multipart/form-data";
-        content: string | Record<string, any>;
-        file?: {
-            url: string;
-            base64?: string | undefined;
-        } | null | undefined;
-    } | undefined;
-};
-/** Create new instance parameter from a request parameter */
-export declare function createParamInstance(param: RequestParameter): RequestExampleParameter;
-/**
- * Create new request example from a request
- * Iterates the name of the example if provided
- */
-export declare function createExampleFromRequest(request: Request, name: string, server?: Server): RequestExample;
-//# sourceMappingURL=request-examples.d.ts.map

package/dist/entities/spec/request-examples.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAKtC;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCvC,CAAA;AAEJ,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,GAAI,QAAQ,uBAAuB,EAAE,2BAIhE,CAAA;AAER,kFAAkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAoHpF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsB/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAKjE,2DAA2D;AAC3D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU/B,CAAA;AAIF;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,cAAc;;;;;;;;;;;;;;;;EAqD9D;AAKD,6DAA6D;AAC7D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,uBAAuB,CAsHpF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CA2HxG"}