@mintlify/validation 0.1.58 → 0.1.60

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

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+export var nameSchema = z
+    .string({ required_error: 'Name is missing.' })
+    .min(1, 'Name cannot be empty.')
+    .trim();
+export var logoSchema = z.union([
+    z.string().min(3, 'Logo needs to 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 var modeToggleSchema = z.object({
+    default: z
+        .enum(['light', 'dark'], {
+        errorMap: function () {
+            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(),
+});
+export var isWhiteLabeledSchema = z.boolean({
+    invalid_type_error: 'isWhiteLabeled must be a boolean. Try writing true or false without the quotes.',
+});
+export var 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 var 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'),
+    })),
+    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" }',
+});
+export var 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(),
+});
+export var 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...`',
+    })
+        .optional(),
+});
+var redirectSchema = z.object({
+    source: z.string(),
+    destination: z.string(),
+});
+export var redirectsSchema = z
+    .array(redirectSchema, {
+    invalid_type_error: 'redirects must be an array of objects with source and destination properties',
+})
+    .refine(function (value) {
+    var keys = value.map(function (obj) { return obj.source; });
+    return new Set(keys).size === keys.length;
+}, {
+    message: 'Sources in the array must be unique.',
+});
+export var createCtaButtonSchema = function (ctaButtonName) {
+    return 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'),
+        })
+            .strict(ctaButtonName +
+            ' can only contain name, url, and type properties. Set a different type if you need to set other fields.'),
+        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.'),
+        })
+            .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.',
+    });
+};

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

@@ -59,4 +59,3 @@ export declare const colorsSchema: z.ZodObject<{
     ultraLight?: any;
     ultraDark?: any;
 }>;
-export type ColorsType = z.infer<typeof colorsSchema>;

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { hexadecimalPattern } from '../hexadecimalPattern.js';
+import { anchorColorSchema } from './anchorColors.js';
+export var colorsSchema = z
+    .object({
+    primary: z
+        .string({ invalid_type_error: 'Primary color must be a string.' })
+        .min(1, 'Color primary is missing.')
+        .regex(hexadecimalPattern, 'Primary color must be a hexadecimal color including the # at the start.'),
+    light: z
+        .string({ invalid_type_error: 'Light color must be a string.' })
+        .regex(hexadecimalPattern, 'Light color must be a hexadecimal color including the # at the start.')
+        .optional(),
+    dark: z
+        .string({ invalid_type_error: 'Dark color must be a string.' })
+        .regex(hexadecimalPattern, 'Dark color must be a hexadecimal color including the # at the start.')
+        .optional(),
+    background: z
+        .object({
+        light: z
+            .string({
+            invalid_type_error: 'Background light color must be a string.',
+        })
+            .regex(hexadecimalPattern, 'Background light color must be a hexadecimal color including the # at the start.')
+            .optional(),
+        dark: z
+            .string({
+            invalid_type_error: 'Background dark color must be a string.',
+        })
+            .regex(hexadecimalPattern, 'Background dark color must be a hexadecimal color including the # at the start.')
+            .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.');

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

@@ -216,7 +216,7 @@ export declare const configSchema: z.ZodObject<{
         type: "github";
         url: string;
     }>]>, "many">>;
-    navigation: z.ZodArray<z.ZodType<import("../types").MintNavigationGroup, z.ZodTypeDef, import("../types").MintNavigationGroup>, "many">;
+    navigation: z.ZodArray<z.ZodType<import("@mintlify/models").NavigationGroup, z.ZodTypeDef, import("@mintlify/models").NavigationGroup>, "many">;
     primaryTab: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
     }, "strict", z.ZodTypeAny, {
@@ -227,21 +227,21 @@ export declare const configSchema: z.ZodObject<{
     topAnchor: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         icon: z.ZodOptional<z.ZodString>;
-        iconType: z.ZodOptional<z.ZodEnum<["brands", "duotone", "light", "sharp-solid", "solid", "thin"]>>;
+        iconType: z.ZodOptional<z.ZodEnum<["brands", "duotone", "light", "regular", "sharp-solid", "solid", "thin"]>>;
     }, "strict", z.ZodTypeAny, {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
     }, {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
     }>>;
     anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         url: z.ZodString;
         icon: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-        iconType: z.ZodOptional<z.ZodEnum<["brands", "duotone", "light", "sharp-solid", "solid", "thin"]>>;
+        iconType: z.ZodOptional<z.ZodEnum<["brands", "duotone", "light", "regular", "sharp-solid", "solid", "thin"]>>;
         color: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
             from: z.ZodString;
             via: z.ZodOptional<z.ZodString>;
@@ -261,7 +261,7 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -273,7 +273,7 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -521,8 +521,8 @@ export declare const configSchema: z.ZodObject<{
         destination: string;
     }[]>>;
 }, "strip", z.ZodTypeAny, {
-    $schema: string;
     name: string;
+    $schema: string;
     favicon: string;
     colors: {
         primary: string;
@@ -540,7 +540,7 @@ export declare const configSchema: z.ZodObject<{
         ultraLight?: any;
         ultraDark?: any;
     };
-    navigation: import("../types").MintNavigationGroup[];
+    navigation: import("@mintlify/models").NavigationGroup[];
     mintlify?: string | undefined;
     logo?: string | {
         light: string;
@@ -596,13 +596,13 @@ export declare const configSchema: z.ZodObject<{
     topAnchor?: {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
     } | undefined;
     anchors?: {
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -615,10 +615,10 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
     }[] | undefined;
-    footerSocials?: Record<string, string> | {
+    footerSocials?: {
         type: string;
         url: string;
-    }[] | undefined;
+    }[] | Record<string, string> | undefined;
     backgroundImage?: string | undefined;
     feedback?: {
         thumbsRating?: boolean | undefined;
@@ -696,7 +696,7 @@ export declare const configSchema: z.ZodObject<{
         ultraLight?: any;
         ultraDark?: any;
     };
-    navigation: import("../types").MintNavigationGroup[];
+    navigation: import("@mintlify/models").NavigationGroup[];
     $schema?: string | undefined;
     mintlify?: string | undefined;
     logo?: string | {
@@ -753,13 +753,13 @@ export declare const configSchema: z.ZodObject<{
     topAnchor?: {
         name: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
     } | undefined;
     anchors?: {
         name: string;
         url: string;
         icon?: string | undefined;
-        iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+        iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
         color?: string | {
             from: string;
             to: string;
@@ -772,10 +772,10 @@ export declare const configSchema: z.ZodObject<{
         name: string;
         url: string;
     }[] | undefined;
-    footerSocials?: Record<string, string> | {
+    footerSocials?: {
         type: string;
         url: string;
-    }[] | undefined;
+    }[] | Record<string, string> | undefined;
     backgroundImage?: string | undefined;
     feedback?: {
         thumbsRating?: boolean | undefined;
@@ -835,4 +835,3 @@ export declare const configSchema: z.ZodObject<{
         destination: string;
     }[] | undefined;
 }>;
-export type ConfigType = z.infer<typeof configSchema>;

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

@@ -0,0 +1,39 @@
+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 { colorsSchema } from './colors.js';
+import { faviconSchema } from './favicon.js';
+import { integrationsSchema } from './integrations.js';
+import { navigationSchema } from './navigation.js';
+import { tabsSchema, primaryTabSchema } from './tabs.js';
+import { versionsSchema } from './versions.js';
+export var configSchema = z.object({
+    $schema: z.string().url().optional().default('https://mintlify.com/schema.json'),
+    mintlify: z.string().optional(),
+    name: nameSchema,
+    logo: logoSchema.optional(),
+    favicon: faviconSchema,
+    openapi: openApiSchema.optional(),
+    api: apiSchema.optional(),
+    modeToggle: modeToggleSchema.optional(),
+    versions: versionsSchema.optional(),
+    metadata: metadataSchema.optional(),
+    colors: colorsSchema,
+    topbarCtaButton: createCtaButtonSchema('topbarCtaButton').optional(),
+    topbarLinks: createCtaButtonSchema('topbarLinks').array().optional(),
+    navigation: navigationSchema,
+    primaryTab: primaryTabSchema.optional(),
+    topAnchor: topAnchorSchema.optional(),
+    anchors: anchorSchema.array().optional(),
+    tabs: tabsSchema.optional(),
+    footerSocials: footerSocialsSchema.optional(),
+    backgroundImage: z.string().optional(),
+    feedback: feedbackSchema.optional(),
+    analytics: analyticsSchema.optional(),
+    integrations: integrationsSchema.optional(),
+    isWhiteLabeled: isWhiteLabeledSchema.optional(),
+    search: searchSchema.optional(),
+    redirects: redirectsSchema.optional(),
+});

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export var 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(function (val) { return val.split('.').pop() !== 'ico'; }, {
+    message: 'Favicon cannot be an .ico file.',
+});

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

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-declare const intercomSchema: z.ZodString;
-declare const frontchatSchema: z.ZodString;
 export declare const integrationsSchema: z.ZodObject<{
     intercom: z.ZodOptional<z.ZodString>;
     frontchat: z.ZodOptional<z.ZodString>;
@@ -11,7 +9,3 @@ export declare const integrationsSchema: z.ZodObject<{
     intercom?: string | undefined;
     frontchat?: string | undefined;
 }>;
-export type IntercomType = z.infer<typeof intercomSchema>;
-export type FrontchatType = z.infer<typeof frontchatSchema>;
-export type IntegrationsType = z.infer<typeof integrationsSchema>;
-export {};

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

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

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

@@ -1,3 +1,16 @@
+import { NavigationGroup } from '@mintlify/models';
 import { z } from 'zod';
-import { MintNavigationGroup } from '../types/navigation';
-export declare const navigationConfigSchema: z.ZodArray<z.ZodType<MintNavigationGroup, z.ZodTypeDef, MintNavigationGroup>, "many">;
+export declare const baseNavigationGroupSchema: z.ZodObject<{
+    group: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    group: string;
+    icon?: string | undefined;
+    version?: string | undefined;
+}, {
+    group: string;
+    icon?: string | undefined;
+    version?: string | undefined;
+}>;
+export declare const navigationSchema: z.ZodArray<z.ZodType<NavigationGroup, z.ZodTypeDef, NavigationGroup>, "many">;

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+// export to allow type testing against @mintlify/models
+export var 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(),
+    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.');
+var navigationGroupSchema = baseNavigationGroupSchema.extend({
+    pages: z.lazy(function () {
+        return z
+            .array(z.union([navigationGroupSchema, z.string().min(1, 'Page cannot be an empty string.')]))
+            .min(1, "Pages array can't be empty.");
+    }),
+});
+export var 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.');

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

@@ -1,15 +1,4 @@
 import { z } from 'zod';
-declare const tabSchema: z.ZodObject<{
-    name: z.ZodString;
-    url: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    url: string;
-}, {
-    name: string;
-    url: string;
-}>;
-export type TabType = z.infer<typeof tabSchema>;
 export declare const tabsSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     url: z.ZodString;
@@ -27,5 +16,3 @@ export declare const primaryTabSchema: z.ZodObject<{
 }, {
     name: string;
 }>;
-export type PrimaryTabType = z.infer<typeof primaryTabSchema>;
-export {};

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+var 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.'),
+});
+export var tabsSchema = tabSchema.array();
+export var 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.',
+})
+    .strict('primaryTab can only have name properties.');

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

@@ -1,14 +1,4 @@
 import { z } from 'zod';
-declare const versionSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    url: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    name: string;
-    url: string;
-}, {
-    name: string;
-    url: string;
-}>]>;
 export declare const versionsSchema: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
     name: z.ZodString;
     url: z.ZodString;
@@ -19,6 +9,3 @@ export declare const versionsSchema: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodOb
     name: string;
     url: string;
 }>]>, "many">;
-export type VersionType = z.infer<typeof versionSchema>;
-export type VersionsType = z.infer<typeof versionsSchema>;
-export {};

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

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

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

@@ -1,4 +1,3 @@
-import { MintValidationResults } from './common';
-import { AnchorsType } from './schemas/anchors';
-import { MintNavigation } from './types/navigation';
-export declare function validateAnchorsWarnings(anchors: AnchorsType | undefined, navigation: MintNavigation | undefined): MintValidationResults;
+import { Anchor, Navigation } from '@mintlify/models';
+import { MintValidationResults } from './common.js';
+export declare function validateAnchorsWarnings(anchors: Anchor[] | undefined, navigation: Navigation | undefined): MintValidationResults;

package/dist/mint-config/validateAnchorsWarnings.js

@@ -0,0 +1,35 @@
+import { MintValidationResults } from './common.js';
+import { navigationSchema } from './schemas/navigation.js';
+export function validateAnchorsWarnings(anchors, navigation) {
+    var results = new MintValidationResults();
+    if (anchors &&
+        Array.isArray(anchors) &&
+        navigation &&
+        navigationSchema.safeParse(navigation).success) {
+        anchors.forEach(function (anchor) {
+            if (!anchor.url.startsWith('mailto:') &&
+                !anchor.url.startsWith('http') &&
+                !anchor.url.startsWith('https') &&
+                !navigation.some(function (nav) { return pageStartsWith(nav, anchor.url); })) {
+                results.warnings.push('No pages in the navigation match anchor ' +
+                    anchor.url +
+                    ' you should have at least one page that starts with ' +
+                    anchor.url);
+            }
+        });
+    }
+    return results;
+}
+function pageStartsWith(navEntry, prefix) {
+    if (typeof navEntry === 'string') {
+        return navEntry.startsWith(prefix);
+    }
+    else if (navEntry.pages == undefined) {
+        return false;
+    }
+    else {
+        return navEntry.pages.some(function (entry) {
+            return pageStartsWith(entry, prefix);
+        });
+    }
+}

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

@@ -1,5 +1,4 @@
-import { MintValidationResults } from './common';
-import { VersionsType } from './schemas/versions';
-import { MintNavigationGroupChild, MintNavigationGroup } from './types/navigation';
-export declare function flattenNavigationVersions(nav: MintNavigationGroupChild[], versions?: string[]): string[];
-export declare function validateVersionsInNavigation(navigation: MintNavigationGroup[] | undefined, versions?: VersionsType | undefined): MintValidationResults;
+import { VersionType, NavigationEntry, NavigationGroup } from '@mintlify/models';
+import { MintValidationResults } from './common.js';
+export declare function flattenNavigationVersions(nav: NavigationEntry[], versions?: string[]): string[];
+export declare function validateVersionsInNavigation(navigation: NavigationGroup[] | undefined, versions?: VersionType[] | undefined): MintValidationResults;

package/dist/mint-config/validateVersionsInNavigation.js

@@ -0,0 +1,55 @@
+import { MintValidationResults } from './common.js';
+import { navigationSchema } from './schemas/navigation.js';
+export function flattenNavigationVersions(nav, versions) {
+    if (versions === void 0) { versions = []; }
+    nav.forEach(function (val) {
+        if (val == null || typeof val === 'string') {
+            return versions;
+        }
+        if (val.version) {
+            versions.push(val.version);
+        }
+        if (!Array.isArray(val.pages)) {
+            return versions;
+        }
+        return flattenNavigationVersions(val.pages, versions);
+    });
+    return versions;
+}
+export function validateVersionsInNavigation(navigation, versions) {
+    if (versions === void 0) { versions = []; }
+    var results = new MintValidationResults();
+    if (navigation == null || !navigationSchema.safeParse(navigation).success) {
+        return results;
+    }
+    var versionsFromNavigation = flattenNavigationVersions(navigation);
+    versionsFromNavigation.forEach(function (v) {
+        if (versions && !versions.includes(v)) {
+            results.errors.push("Version ".concat(v, " is not included in the versions array, but is used in the navigation. Please add ").concat(v, " to the versions array."));
+        }
+    });
+    if (versionsFromNavigation.length === 0 && versions.length > 0) {
+        results.warnings.push('You have versions defined in the config, but no versions are used in the navigation.');
+    }
+    navigation.forEach(function (nav) {
+        var _a;
+        (_a = results.warnings).push.apply(_a, warnVersionNesting(nav, null));
+    });
+    return results;
+}
+function warnVersionNesting(navigation, currentVersion) {
+    if (typeof navigation === 'string') {
+        return [];
+    }
+    var warnings = [];
+    if (navigation.version && currentVersion != null && navigation.version !== currentVersion) {
+        warnings.push("Please do not set versions on groups nested inside a group that already has a version. The group \"".concat(navigation.group, "\" has version \"").concat(navigation.version, "\" set and it is nested in a group that has the version \"").concat(currentVersion, "\" set."));
+    }
+    if (navigation.pages) {
+        return warnings.concat(navigation.pages
+            .map(function (entry) { return warnVersionNesting(entry, currentVersion || navigation.version); })
+            .flat()
+            .filter(Boolean));
+    }
+    return [];
+}

package/dist/openapi/convertOpenApi.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3_1 } from 'openapi-types';
-import type { BodySchema, DataSchemaArray, Endpoint, HttpMethod, ResponseSchema } from './types/endpoint';
+import type { BodySchema, DataSchemaArray, Endpoint, HttpMethod, ResponseSchema } from './types/endpoint.js';
 export declare const generateMessage: (path: string[], messages?: string[]) => string;
 export declare class InvalidSchemaError extends Error {
     constructor(path: string[], ...messages: string[]);