@scalar/oas-utils 0.2.106 → 0.2.108

package/dist/entities/spec/collection.js

@@ -13,16 +13,14 @@ const oasCollectionSchema = z.object({
      */
     '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'),
-    ])
+        .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.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
@@ -49,21 +47,24 @@ const oasCollectionSchema = z.object({
     // security
 });
 const extendedCollectionSchema = z.object({
-    uid: nanoidSchema,
+    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().default(''),
+    selectedServerUid: z.string().brand().optional(),
     /** UIDs which refer to servers on the workspace base */
-    servers: nanoidSchema.array().default([]),
+    servers: z.string().brand().array().default([]),
     /** Request UIDs associated with a collection */
-    requests: nanoidSchema.array().default([]),
+    requests: z.string().brand().array().default([]),
     /** Tag UIDs associated with the collection */
-    tags: nanoidSchema.array().default([]),
+    tags: z.string().brand().array().default([]),
     /** List of requests without tags and top level tag "folders" */
-    children: nanoidSchema.array().default([]),
+    children: z
+        .union([z.string().brand(), z.string().brand()])
+        .array()
+        .default([]),
     /**
      * A link to where this document is stored
      *
@@ -84,10 +85,7 @@ const extendedCollectionSchema = z.object({
      *
      * @defaults to idle for all collections, doesn't mean that it can watch for changes
      */
-    watchModeStatus: z
-        .enum(['IDLE', 'WATCHING', 'ERROR'])
-        .optional()
-        .default('IDLE'),
+    watchModeStatus: z.enum(['IDLE', 'WATCHING', 'ERROR']).optional().default('IDLE'),
 });
 const collectionSchema = oasCollectionSchema.merge(extendedCollectionSchema);
 

package/dist/entities/spec/index.js

@@ -2,7 +2,7 @@ export { collectionSchema, extendedCollectionSchema, oasCollectionSchema } from
 export { oasServerSchema, oasServerVariableSchema, serverSchema } from './server.js';
 export { oasRequestSchema, requestMethods, requestSchema } from './requests.js';
 export { convertExampleToXScalar, createExampleFromRequest, createParamInstance, exampleBodyMime, exampleRequestBodyEncoding, exampleRequestBodySchema, parameterArrayToObject, requestExampleParametersSchema, requestExampleSchema, xScalarExampleBodySchema, xScalarExampleSchema, xScalarFileValueSchema, xScalarFormDataValue } from './request-examples.js';
-export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, oasTagSchema, tagSchema, xScalarNestedSchema } from './spec-objects.js';
+export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, oasTagSchema, omitUndefinedValues, tagSchema, xScalarNestedSchema } from './spec-objects.js';
 export { oasParameterSchema, parameterStyleSchema, parameterTypeSchema } from './parameters.js';
 export { oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeApiKeyIn, securitySchemeSchema } from './security.js';
 export { xScalarEnvVarSchema, xScalarEnvironmentSchema, xScalarEnvironmentsSchema } from './x-scalar-environments.js';

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

@@ -35,10 +35,10 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     }, "strip", import("zod").ZodTypeAny, {
         required: boolean;
         name: string;
-        in: "path" | "query" | "header" | "cookie";
+        in: "path" | "cookie" | "query" | "header";
         deprecated: boolean;
-        description?: string | undefined;
         example?: unknown;
+        description?: string | undefined;
         schema?: unknown;
         content?: unknown;
         style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
@@ -48,10 +48,10 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
         }> | undefined;
     }, {
         name: string;
-        in: "path" | "query" | "header" | "cookie";
+        in: "path" | "cookie" | "query" | "header";
+        example?: unknown;
         required?: boolean | undefined;
         description?: string | undefined;
-        example?: unknown;
         deprecated?: boolean | undefined;
         schema?: unknown;
         content?: unknown;
@@ -61,15 +61,21 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
             summary?: string | undefined;
         }> | undefined;
     }>, "many">>;
-    externalDocs: import("zod").ZodOptional<import("zod").ZodObject<{
-        description: import("zod").ZodOptional<import("zod").ZodString>;
-        url: import("zod").ZodDefault<import("zod").ZodString>;
+    externalDocs: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodObject<{
+        description: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
+        url: import("zod").ZodString;
     }, "strip", import("zod").ZodTypeAny, {
         url: string;
         description?: string | undefined;
     }, {
+        url: string;
+        description?: unknown;
+    }>, {
+        url: string;
         description?: string | undefined;
-        url?: string | undefined;
+    }, {
+        url: string;
+        description?: unknown;
     }>>;
     deprecated: import("zod").ZodOptional<import("zod").ZodBoolean>;
     responses: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
@@ -156,21 +162,21 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     'x-scalar-ignore': import("zod").ZodOptional<import("zod").ZodBoolean>;
 }, "x-scalar-examples">, {
     type: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"request">>>;
-    uid: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    uid: import("zod").ZodBranded<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "operation">;
     path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
     method: import("zod").ZodDefault<import("zod").ZodEnum<["connect", "delete", "get", "head", "options", "patch", "post", "put", "trace"]>>;
-    servers: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "many">>;
-    selectedServerUid: import("zod").ZodDefault<import("zod").ZodString>;
-    examples: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "many">>;
-    selectedSecuritySchemeUids: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, "many">]>, "many">>;
+    servers: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodBranded<import("zod").ZodString, "server">, "many">>;
+    selectedServerUid: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodBranded<import("zod").ZodString, "server">>>>;
+    examples: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodBranded<import("zod").ZodString, "example">, "many">>;
+    selectedSecuritySchemeUids: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodBranded<import("zod").ZodString, "securityScheme">, import("zod").ZodArray<import("zod").ZodBranded<import("zod").ZodString, "securityScheme">, "many">]>, "many">>;
 }>, "strip", import("zod").ZodTypeAny, {
     path: string;
     type: "request";
-    uid: string;
-    selectedSecuritySchemeUids: (string | string[])[];
-    selectedServerUid: string;
-    servers: string[];
-    examples: string[];
+    uid: string & import("zod").BRAND<"operation">;
+    selectedSecuritySchemeUids: ((string & import("zod").BRAND<"securityScheme">) | (string & import("zod").BRAND<"securityScheme">)[])[];
+    selectedServerUid: (string & import("zod").BRAND<"server">) | null;
+    servers: (string & import("zod").BRAND<"server">)[];
+    examples: (string & import("zod").BRAND<"example">)[];
     method: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace";
     description?: string | undefined;
     summary?: string | undefined;
@@ -187,10 +193,10 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     parameters?: {
         required: boolean;
         name: string;
-        in: "path" | "query" | "header" | "cookie";
+        in: "path" | "cookie" | "query" | "header";
         deprecated: boolean;
-        description?: string | undefined;
         example?: unknown;
+        description?: string | undefined;
         schema?: unknown;
         content?: unknown;
         style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
@@ -208,25 +214,25 @@ export declare const operationSchema: import("zod").ZodObject<import("zod").obje
     description?: string | undefined;
     summary?: string | undefined;
     externalDocs?: {
-        description?: string | undefined;
-        url?: string | undefined;
+        url: string;
+        description?: unknown;
     } | undefined;
     'x-internal'?: boolean | undefined;
     'x-scalar-ignore'?: boolean | undefined;
     security?: Record<string, string[] | undefined>[] | undefined;
-    selectedSecuritySchemeUids?: (string | (string | undefined)[] | undefined)[] | undefined;
-    selectedServerUid?: string | undefined;
-    servers?: (string | undefined)[] | undefined;
+    selectedSecuritySchemeUids?: (string | string[])[] | undefined;
+    selectedServerUid?: string | null | undefined;
+    servers?: string[] | undefined;
     tags?: string[] | undefined;
     deprecated?: boolean | undefined;
-    examples?: (string | undefined)[] | undefined;
+    examples?: string[] | undefined;
     operationId?: string | undefined;
     parameters?: {
         name: string;
-        in: "path" | "query" | "header" | "cookie";
+        in: "path" | "cookie" | "query" | "header";
+        example?: unknown;
         required?: boolean | undefined;
         description?: string | undefined;
-        example?: unknown;
         deprecated?: boolean | undefined;
         schema?: unknown;
         content?: unknown;

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

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/operation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,OAAO,IAAI,WAAW,EAE5B,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAC7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgB,CAAA"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgB,CAAA"}

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

@@ -32,10 +32,10 @@ export declare const oasParameterSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     required: boolean;
     name: string;
-    in: "path" | "query" | "header" | "cookie";
+    in: "path" | "cookie" | "query" | "header";
     deprecated: boolean;
-    description?: string | undefined;
     example?: unknown;
+    description?: string | undefined;
     schema?: unknown;
     content?: unknown;
     style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
@@ -45,10 +45,10 @@ export declare const oasParameterSchema: z.ZodObject<{
     }> | undefined;
 }, {
     name: string;
-    in: "path" | "query" | "header" | "cookie";
+    in: "path" | "cookie" | "query" | "header";
+    example?: unknown;
     required?: boolean | undefined;
     description?: string | undefined;
-    example?: unknown;
     deprecated?: boolean | undefined;
     schema?: unknown;
     content?: unknown;

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

@@ -85,7 +85,7 @@ export declare const requestExampleParametersSchema: z.ZodEffects<z.ZodObject<{
     nullable?: boolean | undefined;
 }>;
 /** Convert the array of parameters to an object keyed by the parameter name */
-export declare function parameterArrayToObject(params: RequestExampleParameter[]): Record<string, string>;
+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 xScalarFileValueSchema: z.ZodNullable<z.ZodObject<{
@@ -376,9 +376,9 @@ export declare const xScalarExampleBodySchema: z.ZodObject<{
 }>;
 export type XScalarExampleBody = z.infer<typeof xScalarExampleBodySchema>;
 export declare const requestExampleSchema: z.ZodObject<{
-    uid: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    uid: z.ZodBranded<z.ZodDefault<z.ZodOptional<z.ZodString>>, "example">;
     type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"requestExample">>>;
-    requestUid: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    requestUid: z.ZodOptional<z.ZodBranded<z.ZodString, "operation">>;
     name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     body: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         raw: z.ZodOptional<z.ZodObject<{
@@ -1001,7 +1001,7 @@ export declare const requestExampleSchema: z.ZodObject<{
     serverVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     type: "requestExample";
-    uid: string;
+    uid: string & z.BRAND<"example">;
     name: string;
     parameters: {
         path: {
@@ -1096,7 +1096,7 @@ export declare const requestExampleSchema: z.ZodObject<{
             encoding: "xml" | "text" | "json" | "html" | "javascript" | "yaml" | "edn";
         } | undefined;
     };
-    requestUid: string;
+    requestUid?: (string & z.BRAND<"operation">) | undefined;
     serverVariables?: Record<string, string[]> | undefined;
 }, {
     type?: "requestExample" | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"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"}

package/dist/entities/spec/request-examples.js

@@ -38,26 +38,23 @@ const requestExampleParametersSchema = z
     nullable: z.boolean().optional(),
 })
     // set nullable: to true if type is ['string', 'null']
-    .transform((data) => {
+    .transform((_data) => {
+    const data = { ..._data };
     // type: ['string', 'null'] -> nullable: true
     if (Array.isArray(data.type) && data.type.includes('null')) {
-        data = { ...data, nullable: true };
+        data.nullable = true;
     }
     // Hey, if it’s just one value and 'null', we can make it a string and ditch the 'null'.
-    if (Array.isArray(data.type) &&
-        data.type.length === 2 &&
-        data.type.includes('null')) {
-        data = { ...data, type: data.type.find((item) => item !== 'null') };
+    if (Array.isArray(data.type) && data.type.length === 2 && data.type.includes('null')) {
+        data.type = data.type.find((item) => item !== 'null');
     }
     return data;
 });
 /** Convert the array of parameters to an object keyed by the parameter name */
-function parameterArrayToObject(params) {
-    return params.reduce((map, param) => {
-        map[param.key] = param.value;
-        return map;
-    }, {});
-}
+const parameterArrayToObject = (params) => params.reduce((map, param) => {
+    map[param.key] = param.value;
+    return map;
+}, {});
 const xScalarFileValueSchema = z
     .object({
     url: z.string(),
@@ -86,15 +83,7 @@ const xScalarFormDataValue = z.union([
  *
  * TODO: This list may not be comprehensive enough
  */
-const exampleRequestBodyEncoding = [
-    'json',
-    'text',
-    'html',
-    'javascript',
-    'xml',
-    'yaml',
-    'edn',
-];
+const exampleRequestBodyEncoding = ['json', 'text', 'html', 'javascript', 'xml', 'yaml', 'edn'];
 const exampleBodyMime = [
     'application/json',
     'text/plain',
@@ -132,16 +121,12 @@ const exampleRequestBodySchema = z.object({
         .optional(),
     formData: z
         .object({
-        encoding: z
-            .union([z.literal('form-data'), z.literal('urlencoded')])
-            .default('form-data'),
+        encoding: z.union([z.literal('form-data'), z.literal('urlencoded')]).default('form-data'),
         value: requestExampleParametersSchema.array().default([]),
     })
         .optional(),
     binary: z.instanceof(Blob).optional(),
-    activeBody: z
-        .union([z.literal('raw'), z.literal('formData'), z.literal('binary')])
-        .default('raw'),
+    activeBody: z.union([z.literal('raw'), z.literal('formData'), z.literal('binary')]).default('raw'),
 });
 /** Schema for the OAS serialization of request example bodies */
 const xScalarExampleBodySchema = z.object({
@@ -158,18 +143,16 @@ const xScalarExampleBodySchema = z.object({
 // ---------------------------------------------------------------------------
 // Example Schema
 const requestExampleSchema = z.object({
-    uid: nanoidSchema,
+    uid: nanoidSchema.brand(),
     type: z.literal('requestExample').optional().default('requestExample'),
-    requestUid: nanoidSchema,
+    requestUid: z.string().brand().optional(),
     name: z.string().optional().default('Name'),
     body: exampleRequestBodySchema.optional().default({}),
     parameters: z
         .object({
         path: requestExampleParametersSchema.array().default([]),
         query: requestExampleParametersSchema.array().default([]),
-        headers: requestExampleParametersSchema
-            .array()
-            .default([{ key: 'Accept', value: '*/*', enabled: true }]),
+        headers: requestExampleParametersSchema.array().default([{ key: 'Accept', value: '*/*', enabled: true }]),
         cookies: requestExampleParametersSchema.array().default([]),
     })
         .optional()
@@ -178,9 +161,7 @@ const requestExampleSchema = z.object({
     serverVariables: z.record(z.string(), z.array(z.string())).optional(),
 });
 /** For OAS serialization we just store the simple key/value pairs */
-const xScalarExampleParameterSchema = z
-    .record(z.string(), z.string())
-    .optional();
+const xScalarExampleParameterSchema = z.record(z.string(), z.string()).optional();
 /** Schema for the OAS serialization of request examples */
 const xScalarExampleSchema = z.object({
     /** TODO: Should this be required? */
@@ -211,10 +192,7 @@ function convertExampleToXScalar(example) {
     }
     if (active === 'formData' && example.body?.[active]) {
         const body = example.body[active];
-        xScalarBody.encoding =
-            body.encoding === 'form-data'
-                ? 'multipart/form-data'
-                : 'application/x-www-form-urlencoded';
+        xScalarBody.encoding = body.encoding === 'form-data' ? 'multipart/form-data' : 'application/x-www-form-urlencoded';
         // TODO: Need to allow users to set these properties
         xScalarBody.content = body.value.reduce((map, param) => {
             /** TODO: We need to ensure only file or value is set */
@@ -231,8 +209,7 @@ function convertExampleToXScalar(example) {
         }, {});
     }
     if (example.body?.activeBody === 'raw') {
-        xScalarBody.encoding =
-            contentMapping[example.body.raw?.encoding ?? 'text'] ?? 'text/plain';
+        xScalarBody.encoding = contentMapping[example.body.raw?.encoding ?? 'text'] ?? 'text/plain';
         xScalarBody.content = example.body.raw?.value ?? '';
     }
     const parameters = {};
@@ -243,9 +220,7 @@ function convertExampleToXScalar(example) {
     });
     return xScalarExampleSchema.parse({
         /** Only add the body if we have content or the body should be a file */
-        body: xScalarBody.content || xScalarBody.encoding === 'binary'
-            ? xScalarBody
-            : undefined,
+        body: xScalarBody.content || xScalarBody.encoding === 'binary' ? xScalarBody : undefined,
         parameters,
     });
 }
@@ -262,12 +237,7 @@ function createParamInstance(param) {
      * - Need to handle non-string parameters much better
      * - Need to handle unions/array values for schema
      */
-    const value = String(schema?.default ??
-        schema?.examples?.[0] ??
-        schema?.example ??
-        firstExample?.value ??
-        param.example ??
-        '');
+    const value = String(schema?.default ?? schema?.examples?.[0] ?? schema?.example ?? firstExample?.value ?? param.example ?? '');
     // Handle non-string enums and enums within items for array types
     const parseEnum = schema?.enum && schema?.type !== 'string'
         ? schema.enum?.map(String)
@@ -275,9 +245,7 @@ function createParamInstance(param) {
             ? schema.items.enum.map(String)
             : schema?.enum;
     // Handle non-string examples
-    const parseExamples = schema?.examples && schema?.type !== 'string'
-        ? schema.examples?.map(String)
-        : schema?.examples;
+    const parseExamples = schema?.examples && schema?.type !== 'string' ? schema.examples?.map(String) : schema?.examples;
     // safe parse the example
     const example = schemaModel({
         ...schema,
@@ -294,8 +262,7 @@ function createParamInstance(param) {
         console.warn(`Example at ${param.name} is invalid.`);
         return requestExampleParametersSchema.parse({});
     }
-    else
-        return example;
+    return example;
 }
 /**
  * Create new request example from a request
@@ -319,48 +286,49 @@ function createExampleFromRequest(request, name, server) {
         parameters.headers = parameters.header;
         parameters.header = [];
     }
+    // Get content type header
+    const contentTypeHeader = parameters.headers.find((h) => h.key.toLowerCase() === 'content-type');
     // ---------------------------------------------------------------------------
     // Handle request body defaulting for various content type encodings
     const body = {
         activeBody: 'raw',
     };
-    if (request.requestBody) {
+    // If we have a request body or a content type header
+    if (request.requestBody || contentTypeHeader?.value) {
         const requestBody = getRequestBodyFromOperation({
             path: request.path,
             information: {
                 requestBody: request.requestBody,
             },
         });
-        if (requestBody?.mimeType === 'application/json') {
+        const contentType = request.requestBody ? requestBody?.mimeType : contentTypeHeader?.value;
+        if (contentType === 'application/json') {
             body.activeBody = 'raw';
             body.raw = {
                 encoding: 'json',
-                value: requestBody.text ?? JSON.stringify({}),
+                value: requestBody?.text ?? JSON.stringify({}),
             };
         }
-        if (requestBody?.mimeType === 'application/xml') {
+        if (contentType === 'application/xml') {
             body.activeBody = 'raw';
             body.raw = {
                 encoding: 'xml',
-                value: requestBody.text ?? '',
+                value: requestBody?.text ?? '',
             };
         }
         /**
          *  TODO: Are we loading example files from somewhere based on the spec?
          *  How are we handling the body values
          */
-        if (requestBody?.mimeType === 'application/octet-stream') {
+        if (contentType === 'application/octet-stream') {
             body.activeBody = 'binary';
             body.binary = undefined;
         }
-        if (requestBody?.mimeType === 'application/x-www-form-urlencoded' ||
-            requestBody?.mimeType === 'multipart/form-data') {
+        if (contentType === 'application/x-www-form-urlencoded' || contentType === 'multipart/form-data') {
             body.activeBody = 'formData';
             body.formData = {
-                encoding: requestBody.mimeType === 'application/x-www-form-urlencoded'
-                    ? 'urlencoded'
-                    : 'form-data',
-                value: (requestBody.params || []).map((param) => ({
+                encoding: contentType === 'application/x-www-form-urlencoded' ? 'urlencoded' : 'form-data',
+                value: (requestBody?.params || []).map((param) => ({
                     key: param.name,
                     value: param.value || '',
                     enabled: true,
@@ -368,8 +336,7 @@ function createExampleFromRequest(request, name, server) {
             };
         }
         // Add the content-type header if it doesn't exist
-        if (requestBody?.mimeType &&
-            !parameters.headers.find((h) => h.key.toLowerCase() === 'content-type')) {
+        if (requestBody?.mimeType && !contentTypeHeader) {
             parameters.headers.push({
                 key: 'Content-Type',
                 value: requestBody.mimeType,
@@ -390,8 +357,7 @@ function createExampleFromRequest(request, name, server) {
         console.warn(`Example at ${request.uid} is invalid.`);
         return requestExampleSchema.parse({});
     }
-    else
-        return example;
+    return example;
 }
 
 export { convertExampleToXScalar, createExampleFromRequest, createParamInstance, exampleBodyMime, exampleRequestBodyEncoding, exampleRequestBodySchema, parameterArrayToObject, requestExampleParametersSchema, requestExampleSchema, xScalarExampleBodySchema, xScalarExampleSchema, xScalarFileValueSchema, xScalarFormDataValue };