@mintlify/validation 0.1.125 → 0.1.126

package/dist/mint-config/schemas/apiReference.js

@@ -1,48 +1,21 @@
 import { z } from 'zod';
-export const openApiSchema = z.union([
-    z.string({
-        invalid_type_error: 'openapi must be a string or an array of strings of absolute or relative URLs pointing to your OpenAPI file.',
-    }),
-    z.array(z.string({
-        invalid_type_error: 'openapi must be a string or an array of strings of absolute or relative URLs pointing to your OpenAPI file.',
-    })),
-]);
+export const openApiSchema = z
+    .union([z.string(), z.array(z.string())])
+    .describe('A string or an array of strings of absolute or relative urls pointing to your OpenAPI files');
 export const apiSchema = z
     .object({
-    baseUrl: z
-        .union([
-        z.string().url('api.baseUrl must be a valid URL.'),
-        z.array(z.string().url('api.baseUrl array entries must be valid URLs.')),
-    ])
-        .optional(),
+    baseUrl: z.union([z.string().url(), z.array(z.string().url())]).optional(),
     auth: z
         .object({
-        method: z
-            .enum(['bearer', 'basic', 'key', 'cobo'], {
-            errorMap: () => {
-                return {
-                    message: 'api.auth.method has to be one of: bearer, basic, or key',
-                };
-            },
-        })
-            .optional(),
+        method: z.enum(['bearer', 'basic', 'key', 'cobo']).optional(),
         name: z.string().optional(),
         inputPrefix: z.string().optional(),
     })
-        .strict('api.auth can only contain method, name, and inputPrefix.')
+        .strict()
         .optional(),
     playground: z
         .object({
-        mode: z
-            .enum(['show', 'simple', 'hide'], {
-            errorMap: () => {
-                return {
-                    message: 'api.playground.mode must be one of the following strings: show, simple, or hide',
-                };
-            },
-        })
-            .optional()
-            .default('show'),
+        mode: z.enum(['show', 'simple', 'hide']).optional().default('show'),
     })
         .optional(),
     request: z
@@ -54,12 +27,6 @@ export const apiSchema = z
             .optional(),
     })
         .optional(),
-    maintainOrder: z
-        .boolean({
-        invalid_type_error: 'maintainOrder must be a boolean. Try writing true or false without the quotes.',
-    })
-        .optional(),
-}, {
-    invalid_type_error: 'api must be an object. The object can have baseUrl, auth, and playground as properties.',
+    maintainOrder: z.boolean().optional(),
 })
-    .strict('api can only contain baseUrl, auth, and playground as properties.');
+    .strict();

package/dist/mint-config/schemas/basics.d.ts

@@ -71,7 +71,7 @@ export declare const redirectsSchema: z.ZodEffects<z.ZodArray<z.ZodObject<{
     source: string;
     destination: string;
 }[]>;
-export declare const createCtaButtonSchema: (ctaButtonName: string) => z.ZodUnion<[z.ZodObject<{
+export declare const ctaButtonSchema: z.ZodUnion<[z.ZodObject<{
     type: z.ZodOptional<z.ZodLiteral<"link">>;
     name: z.ZodString;
     url: z.ZodString;

package/dist/mint-config/schemas/basics.js

@@ -1,120 +1,59 @@
 import { z } from 'zod';
-export const nameSchema = z
-    .string({ required_error: 'Name is missing.' })
-    .min(1, 'Name cannot be empty.')
-    .trim();
+export const nameSchema = z.string().trim().nonempty();
 export const logoSchema = z.union([
-    z.string().min(3, 'Logo needs to be a path to your logo file including the file extension.'),
+    z.string().min(3, 'Must be a path to your logo file including the file extension'),
     z.object({
         light: z.string(),
         dark: z.string(),
         href: z.string().optional(),
     }),
-], {
-    invalid_type_error: 'Logo must be a string or an object with light and dark properties.',
-});
+]);
 export const modeToggleSchema = z.object({
-    default: z
-        .enum(['light', 'dark'], {
-        errorMap: () => {
-            return {
-                message: 'modeToggleSchema.default must be one of the following: light or dark',
-            };
-        },
-    })
-        .optional(),
-    isHidden: z
-        .boolean({
-        invalid_type_error: 'isHidden must be a boolean. Try writing true or false without the quotes.',
-    })
-        .optional(),
+    default: z.enum(['light', 'dark']).optional(),
+    isHidden: z.boolean().optional(),
 });
-export const isWhiteLabeledSchema = z.boolean({
-    invalid_type_error: 'isWhiteLabeled must be a boolean. Try writing true or false without the quotes.',
-});
-export const metadataSchema = z.record(z.string({ invalid_type_error: 'metadata keys must be strings' }), z
-    .string({ invalid_type_error: 'metadata values must be strings' })
-    .min(1, 'metadata values must not be empty'));
-export const footerSocialsSchema = z.union([
+export const isWhiteLabeledSchema = z.boolean();
+export const metadataSchema = z.record(z.string(), z.string().nonempty());
+export const footerSocialsSchema = z
+    .union([
     // TO DO: deprecate array types
     z.array(z.object({
         type: z.string(),
-        url: z.string().url('footerSocials url must be a valid url'),
+        url: z.string().url('Must be a valid url'),
     })),
-    z.record(z.string().trim().min(1, 'footerSocials name (the key in the object) must not be empty'), z.string().url('footerSocials url (the value in the object) must be a valid url')),
-], {
-    invalid_type_error: 'footerSocials must be an object where the key is the name of the social media and the value is the url to your profile. For example: { "twitter": "https://twitter.com/mintlify" }',
-});
+    z.record(z.string().trim().nonempty(), z.string().url('Must be a valid url')),
+])
+    .describe('An object in which each key is the name of a social media platform, and each value is the url to your profile. For example: { "twitter": "https://twitter.com/mintlify" }');
 export const feedbackSchema = z.object({
-    thumbsRating: z
-        .boolean({
-        invalid_type_error: 'thumbsRating must be a boolean. Try writing true or false without the quotes.',
-    })
-        .optional(),
-    suggestEdit: z
-        .boolean({
-        invalid_type_error: 'suggestEdit must be a boolean. Try writing true or false without the quotes.',
-    })
-        .optional(),
-    raiseIssue: z
-        .boolean({
-        invalid_type_error: 'raiseIssue must be a boolean. Try writing true or false without the quotes.',
-    })
-        .optional(),
+    thumbsRating: z.boolean().optional(),
+    suggestEdit: z.boolean().optional(),
+    raiseIssue: z.boolean().optional(),
 });
 export const searchSchema = z.object({
-    prompt: z
-        .string({
-        invalid_type_error: 'search.prompt must be a string. If this field is undefined, the default prompt is `Search or ask...`',
-    })
-        .optional(),
+    prompt: z.string().optional(),
 });
 const redirectSchema = z.object({
     source: z.string(),
     destination: z.string(),
 });
-export const redirectsSchema = z
-    .array(redirectSchema, {
-    invalid_type_error: 'redirects must be an array of objects with source and destination properties',
-})
-    .refine((value) => {
+export const redirectsSchema = z.array(redirectSchema).refine((value) => {
     const keys = value.map((obj) => obj.source);
     return new Set(keys).size === keys.length;
-}, {
-    message: 'Sources in the array must be unique.',
-});
-export const createCtaButtonSchema = (ctaButtonName) => z.union([
+}, 'Sources in the array must be unique');
+export const ctaButtonSchema = z
+    .union([
     z
         .object({
         type: z.literal('link').optional(),
-        name: z.string({
-            required_error: 'Name must be defined when using a CTA button',
-            invalid_type_error: 'Name must be a string',
-        }),
-        url: z
-            .string({
-            required_error: ctaButtonName + '.url is missing',
-            invalid_type_error: ctaButtonName + '.url must be a string',
-        })
-            .min(1, ctaButtonName + '.url cannot be empty'),
+        name: z.string(),
+        url: z.string().nonempty(),
     })
-        .strict(ctaButtonName +
-        ' can only contain name, url, and type properties. Set a different type if you need to set other fields.'),
+        .strict(),
     z
         .object({
         type: z.literal('github'),
-        url: z
-            .string({
-            required_error: ctaButtonName +
-                '.url is missing. Please set the url to a link to your GitHub repository.',
-            invalid_type_error: ctaButtonName +
-                '.url must be a string. Specifically, set the url to a link to your GitHub repository.',
-        })
-            .url(ctaButtonName + '.url must be a valid url pointing to your GitHub repository.'),
+        url: z.string().url('Must be a valid URL').describe('A link to your GitHub repository'),
     })
-        .strict(ctaButtonName +
-        ' can only contain url and type properties when type="github". Please delete any other properties you have set.'),
-], {
-    invalid_type_error: ctaButtonName +
-        ' must be an object. The object can have type="link" (the default) if you define a url and a name. You can also have type="github" if you define a url pointing to your GitHub repo and set the type in the object.',
-});
+        .strict(),
+])
+    .describe('An object containing the configuration for a Call-to-Action button. The object can have { "type": "link" } (the default) if you define a url and a name. For links to your GitHub repo, use { "type": "github" }');

package/dist/mint-config/schemas/colors.js

@@ -3,21 +3,19 @@ import { anchorColorSchema } from './anchorColors.js';
 import { hexColor } from './hexColor.js';
 export const colorsSchema = z
     .object({
-    primary: hexColor('Primary color'),
-    light: hexColor('Light color').optional(),
-    dark: hexColor('Dark color').optional(),
+    primary: hexColor,
+    light: hexColor.optional(),
+    dark: hexColor.optional(),
     background: z
         .object({
-        light: hexColor('Background light color').optional(),
-        dark: hexColor('Background dark color').optional(),
+        light: hexColor.optional(),
+        dark: hexColor.optional(),
     })
         .optional(),
     anchors: anchorColorSchema.optional(),
     // Prevent strict() from throwing an error when the user defines a deprecated ultraLight / ultraDark color.
     ultraLight: z.any().optional(),
     ultraDark: z.any().optional(),
-}, {
-    required_error: 'Colors are missing. You need to define at least the primary color. For example: { "colors": { "primary": "#ff0000" } }',
-    invalid_type_error: 'Colors must be an object.',
 })
-    .strict('Some of the colors in mint.json are invalid, did you make a typo? We only accept primary, light, dark, background, and anchors.');
+    .strict()
+    .describe('The colors to use in your documentation. At the very least, you must define the primary color. For example: { "colors": { "primary": "#ff0000" } }');

package/dist/mint-config/schemas/config.d.ts

@@ -366,7 +366,7 @@ export declare const mintConfigSchema: z.ZodObject<{
             hjsv: string;
         }>>;
         koala: z.ZodOptional<z.ZodObject<{
-            publicApiKey: z.ZodEffects<z.ZodString, string, string>;
+            publicApiKey: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             publicApiKey: string;
         }, {
@@ -531,7 +531,6 @@ export declare const mintConfigSchema: z.ZodObject<{
         indexHiddenPages?: boolean | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    navigation: import("@mintlify/models").NavigationGroup[];
     name: string;
     $schema: string;
     favicon: string;
@@ -551,6 +550,7 @@ export declare const mintConfigSchema: z.ZodObject<{
         ultraLight?: any;
         ultraDark?: any;
     };
+    navigation: import("@mintlify/models").NavigationGroup[];
     mintlify?: string | undefined;
     logo?: string | {
         light: string;
@@ -692,7 +692,6 @@ export declare const mintConfigSchema: z.ZodObject<{
         indexHiddenPages?: boolean | undefined;
     } | undefined;
 }, {
-    navigation: import("@mintlify/models").NavigationGroup[];
     name: string;
     favicon: string;
     colors: {
@@ -711,6 +710,7 @@ export declare const mintConfigSchema: z.ZodObject<{
         ultraLight?: any;
         ultraDark?: any;
     };
+    navigation: import("@mintlify/models").NavigationGroup[];
     $schema?: string | undefined;
     mintlify?: string | undefined;
     logo?: string | {

package/dist/mint-config/schemas/config.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { analyticsSchema } from './analytics.js';
 import { anchorSchema, topAnchorSchema } from './anchors.js';
 import { apiSchema, openApiSchema } from './apiReference.js';
-import { nameSchema, logoSchema, modeToggleSchema, isWhiteLabeledSchema, footerSocialsSchema, feedbackSchema, metadataSchema, createCtaButtonSchema, searchSchema, redirectsSchema, } from './basics.js';
+import { nameSchema, logoSchema, modeToggleSchema, isWhiteLabeledSchema, footerSocialsSchema, feedbackSchema, metadataSchema, ctaButtonSchema, searchSchema, redirectsSchema, } from './basics.js';
 import { colorsSchema } from './colors.js';
 import { faviconSchema } from './favicon.js';
 import { integrationsSchema } from './integrations.js';
@@ -22,8 +22,8 @@ export const mintConfigSchema = z.object({
     versions: versionsSchema.optional(),
     metadata: metadataSchema.optional(),
     colors: colorsSchema,
-    topbarCtaButton: createCtaButtonSchema('topbarCtaButton').optional(),
-    topbarLinks: createCtaButtonSchema('topbarLinks').array().optional(),
+    topbarCtaButton: ctaButtonSchema.optional(),
+    topbarLinks: ctaButtonSchema.array().optional(),
     navigation: navigationSchema,
     primaryTab: primaryTabSchema.optional(),
     topAnchor: topAnchorSchema.optional(),

package/dist/mint-config/schemas/favicon.js

@@ -1,9 +1,5 @@
 import { z } from 'zod';
 export const faviconSchema = z
-    .string({
-    required_error: 'Favicon is missing. Please set favicon to the path of your favicon file. We recommend using a .svg or .png file. Mintlify automatically resizes your favicon to the sizes needed.',
-    invalid_type_error: 'Favicon must be a string path pointing to the favicon file in your Mintlify folder.',
-})
-    .refine((val) => val.split('.').pop() !== 'ico', {
-    message: 'Favicon cannot be an .ico file.',
-});
+    .string()
+    .refine((val) => !val.endsWith('.ico'), 'Favicon cannot be an .ico file')
+    .describe('A path pointing to the favicon file in your docs folder, including the file extension. We recommend using an .svg or .png file. The favicon will automatically be resized to the appropriate sizes');

package/dist/mint-config/schemas/hexColor.d.ts

@@ -1,2 +1,2 @@
 import { z } from 'zod';
-export declare const hexColor: (name: string) => z.ZodString;
+export declare const hexColor: z.ZodString;

package/dist/mint-config/schemas/hexColor.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
 const hexColorRegex = /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;
-export const hexColor = (name) => z
-    .string({ invalid_type_error: `${name} must be a string` })
-    .regex(hexColorRegex, `${name} must be a hex color string, with a leading #`);
+export const hexColor = z
+    .string()
+    .regex(hexColorRegex, 'Must be a hex color string, with a leading #');

package/dist/mint-config/schemas/integrations.js

@@ -1,11 +1,7 @@
 import { z } from 'zod';
-const intercomSchema = z
-    .string({ invalid_type_error: 'integrations.intercom must be a string' })
-    .min(6, 'integrations.intercom must be a valid Intercom app ID');
-const frontchatSchema = z
-    .string({ invalid_type_error: 'integrations.frontchat must be a string' })
-    .min(6, 'integrations.frontchat must be a valid Front chat snippet id');
+const intercomSchema = z.string().min(6, 'Must be a valid Intercom app ID');
+const frontchatSchema = z.string().min(6, 'Must be a valid Front chat snippet id');
 export const integrationsSchema = z.object({
     intercom: intercomSchema.optional(),
     frontchat: frontchatSchema.optional(),
-}, { invalid_type_error: 'integrations must be an object' });
+});

package/dist/mint-config/schemas/navigation.js

@@ -5,31 +5,13 @@ export const baseNavigationGroupSchema = z
     .object({
     // We allow top-level groups to be an empty string if the user wants to hide the title.
     // Future work should refactor this so nested groups are non-empty strings.
-    group: z.string({
-        required_error: 'Missing navigation group name.',
-        invalid_type_error: 'Group must be a string. We use the group name to create the navigation sidebar.',
-    }),
-    icon: z.string({ invalid_type_error: 'Icon must be a string.' }).optional(),
-    iconType: z
-        .enum(iconTypes, {
-        errorMap: () => {
-            return {
-                message: 'group iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
-            };
-        },
-    })
-        .optional(),
-    version: z.string({ invalid_type_error: 'Version must be a string.' }).optional(),
-}, { invalid_type_error: 'Navigation entry must be an object.' })
-    .strict('Navigation entry can only contain group, pages, icon, and version.');
+    group: z.string().describe('The label for this group in the navigation sidebar'),
+    icon: z.string().optional(),
+    iconType: z.enum(iconTypes).optional(),
+    version: z.string().optional(),
+})
+    .strict();
 const navigationGroupSchema = baseNavigationGroupSchema.extend({
-    pages: z.lazy(() => z
-        .array(z.union([navigationGroupSchema, z.string().min(1, 'Page cannot be an empty string.')]))
-        .min(1, "Pages array can't be empty.")),
+    pages: z.lazy(() => z.array(z.union([navigationGroupSchema, z.string().nonempty()])).nonempty()),
 });
-export const navigationSchema = z
-    .array(navigationGroupSchema, {
-    required_error: 'Navigation is missing.',
-    invalid_type_error: 'Navigation must be an array.',
-})
-    .min(1, 'Navigation cannot be an empty array. Please add at least one group.');
+export const navigationSchema = z.array(navigationGroupSchema).min(1);

package/dist/mint-config/schemas/tabs.js

@@ -1,33 +1,12 @@
 import { z } from 'zod';
 const tabSchema = z.object({
-    name: z
-        .string({
-        required_error: 'Every tab must have a name.',
-        invalid_type_error: 'Tab name must be a string.',
-    })
-        .trim()
-        .min(1, 'Tab name is empty.'),
-    url: z
-        .string({
-        required_error: 'Every tab must have a url',
-        invalid_type_error: 'Tab url must be a string.',
-    })
-        .trim()
-        .min(1, 'Tab URL is missing.'),
-    version: z
-        .string({
-        invalid_type_error: 'Version must be a string in the versions array.',
-    })
-        .optional(),
+    name: z.string().trim().nonempty(),
+    url: z.string().trim().nonempty(),
+    version: z.string().optional(),
 });
 export const tabsSchema = tabSchema.array();
 export const primaryTabSchema = z
     .object({
-    name: z.string({
-        required_error: 'primaryTab.name is missing, set it or delete the entire primaryTab property.',
-        invalid_type_error: 'primaryTab.name must be a string',
-    }),
-}, {
-    invalid_type_error: 'primaryTab must be an object with a name property.',
+    name: z.string(),
 })
-    .strict('primaryTab can only have name properties.');
+    .strict();

package/dist/mint-config/schemas/versions.js

@@ -1,13 +1,11 @@
 import { z } from 'zod';
 const versionSchema = z.union([
-    z.string({ invalid_type_error: 'Versions must be an array of strings.' }),
+    z.string(),
     z
         .object({
-        name: z.string().min(1, 'Name cannot be an empty string.'),
-        url: z.string().min(1, 'URL cannot be an empty string.'),
+        name: z.string().nonempty(),
+        url: z.string().nonempty(),
     })
-        .strict('Object must contain name and url properties'),
+        .strict(),
 ]);
-export const versionsSchema = z
-    .array(versionSchema)
-    .min(1, 'Versions array cannot be empty. Either delete the property or add strings to the array.');
+export const versionsSchema = z.array(versionSchema).min(1);