@mintlify/validation 0.1.58 → 0.1.60

package/dist/mint-config/flattenUnionErrorMessages.js

@@ -0,0 +1,19 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// TO DO: Write unit tests for this function.
+// TO DO: Prettify the output instead of just returning JSON objects.
+export function flattenUnionErrorMessages(unionErrors) {
+    return unionErrors.reduce(function (acc, unionError) {
+        if (Array.isArray(unionError.unionErrors) && unionError.unionErrors.length > 0) {
+            return __spreadArray(__spreadArray([], acc, true), flattenUnionErrorMessages(unionError.unionErrors), true);
+        }
+        return __spreadArray(__spreadArray([], acc, true), [unionError.message], false);
+    }, []);
+}

package/dist/mint-config/hexadecimalPattern.js

@@ -0,0 +1 @@
+export var hexadecimalPattern = /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;

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

@@ -1,106 +1,4 @@
 import { z } from 'zod';
-declare const amplitudeConfigInterfaceSchema: z.ZodObject<{
-    apiKey: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    apiKey: string;
-}, {
-    apiKey: string;
-}>;
-declare const clearbitConfigInterfaceSchema: z.ZodObject<{
-    publicApiKey: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    publicApiKey: string;
-}, {
-    publicApiKey: string;
-}>;
-declare const fathomConfigInterfaceSchema: z.ZodObject<{
-    siteId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    siteId: string;
-}, {
-    siteId: string;
-}>;
-declare const googleAnalyticsConfigInterfaceSchema: z.ZodObject<{
-    measurementId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    measurementId: string;
-}, {
-    measurementId: string;
-}>;
-declare const googleTagManagerConfigInterfaceSchema: z.ZodObject<{
-    tagId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    tagId: string;
-}, {
-    tagId: string;
-}>;
-declare const hotjarConfigInterfaceSchema: z.ZodObject<{
-    hjid: z.ZodString;
-    hjsv: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    hjid: string;
-    hjsv: string;
-}, {
-    hjid: string;
-    hjsv: string;
-}>;
-declare const koalaConfigInterfaceSchema: z.ZodObject<{
-    publicApiKey: z.ZodEffects<z.ZodString, string, string>;
-}, "strip", z.ZodTypeAny, {
-    publicApiKey: string;
-}, {
-    publicApiKey: string;
-}>;
-declare const logrocketConfigInterfaceSchema: z.ZodObject<{
-    appId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    appId: string;
-}, {
-    appId: string;
-}>;
-declare const mixpanelConfigInterfaceSchema: z.ZodObject<{
-    projectToken: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    projectToken: string;
-}, {
-    projectToken: string;
-}>;
-declare const pirschConfigInterfaceSchema: z.ZodObject<{
-    id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
-declare const postHogConfigInterfaceSchema: z.ZodObject<{
-    apiKey: z.ZodString;
-    apiHost: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    apiKey: string;
-    apiHost?: string | undefined;
-}, {
-    apiKey: string;
-    apiHost?: string | undefined;
-}>;
-declare const plausibleConfigInterfaceSchema: z.ZodObject<{
-    domain: z.ZodEffects<z.ZodString, string, string>;
-}, "strip", z.ZodTypeAny, {
-    domain: string;
-}, {
-    domain: string;
-}>;
-export type AmplitudeConfigInterface = z.infer<typeof amplitudeConfigInterfaceSchema>;
-export type ClearbitConfigInterface = z.infer<typeof clearbitConfigInterfaceSchema>;
-export type FathomConfigInterface = z.infer<typeof fathomConfigInterfaceSchema>;
-export type GoogleAnalyticsConfigInterface = z.infer<typeof googleAnalyticsConfigInterfaceSchema>;
-export type GoogleTagManagerConfigInterface = z.infer<typeof googleTagManagerConfigInterfaceSchema>;
-export type HotjarConfigInterface = z.infer<typeof hotjarConfigInterfaceSchema>;
-export type KoalaConfigInterface = z.infer<typeof koalaConfigInterfaceSchema>;
-export type LogrocketConfigInterface = z.infer<typeof logrocketConfigInterfaceSchema>;
-export type MixpanelConfigInterface = z.infer<typeof mixpanelConfigInterfaceSchema>;
-export type PirschConfigInterface = z.infer<typeof pirschConfigInterfaceSchema>;
-export type PostHogConfigInterface = z.infer<typeof postHogConfigInterfaceSchema>;
-export type PlausibleConfigInterface = z.infer<typeof plausibleConfigInterfaceSchema>;
 export declare const analyticsSchema: z.ZodObject<{
     amplitude: z.ZodOptional<z.ZodObject<{
         apiKey: z.ZodString;
@@ -271,5 +169,3 @@ export declare const analyticsSchema: z.ZodObject<{
         domain: string;
     } | undefined;
 }>;
-export type AnalyticsType = z.infer<typeof analyticsSchema>;
-export {};

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

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+var amplitudeConfigInterfaceSchema = z.object({
+    apiKey: z.string({
+        required_error: 'Amplitude apiKey is missing.',
+        invalid_type_error: 'Amplitude apiKey must be a string.',
+    }),
+}, {
+    invalid_type_error: 'Amplitude analytics config must be an object with an apiKey property.',
+});
+var clearbitConfigInterfaceSchema = z.object({
+    publicApiKey: z.string({
+        required_error: 'Clearbit publicApiKey is missing.',
+        invalid_type_error: 'Clearbit publicApiKey must be a string.',
+    }),
+}, {
+    invalid_type_error: 'Clearbit config must be an object with a publicApiKey property.',
+});
+var fathomConfigInterfaceSchema = z.object({
+    siteId: z.string({
+        required_error: 'Fathom siteId is missing.',
+        invalid_type_error: 'Fathom siteId must be a string.',
+    }),
+}, {
+    invalid_type_error: 'Fathom analytics config must be an object with a siteId property.',
+});
+var googleAnalyticsConfigInterfaceSchema = z.object({
+    measurementId: z
+        .string({
+        required_error: 'Google Analytics measurementId is missing.',
+        invalid_type_error: 'Google Analytics measurementId must be a string.',
+    })
+        .startsWith('G', 'Google Analytics measurementId must start with G.'),
+}, {
+    invalid_type_error: 'Google Analytics config must be an object with a measurementId property.',
+});
+var googleTagManagerConfigInterfaceSchema = z.object({
+    tagId: z
+        .string({
+        required_error: 'Google Tag Manager tagId is missing.',
+        invalid_type_error: 'Google Tag Manager tagId must be a string.',
+    })
+        .startsWith('G', 'Google Tag Manager tagId must start with G.'),
+}, {
+    invalid_type_error: 'Google Tag Manager config must be an object with a tagId property.',
+});
+var hotjarConfigInterfaceSchema = z.object({
+    hjid: z.string({
+        required_error: 'Hotjar hjid is missing.',
+        invalid_type_error: 'Hotjar hjid must be a string.',
+    }),
+    hjsv: z.string({
+        required_error: 'Hotjar hjsv is missing.',
+        invalid_type_error: 'Hotjar hjsv must be a string.',
+    }),
+}, {
+    invalid_type_error: 'Hotjar config must be an object with a hjid and hjsv property.',
+});
+var koalaConfigInterfaceSchema = z.object({
+    publicApiKey: z
+        .string({
+        required_error: 'Public Api Key is required for the Koala snippet to run.',
+        invalid_type_error: 'Koala Public Api Key must be a string.',
+    })
+        .refine(function (publicApiKey) { return publicApiKey.length >= 2; }, 'Koala Public Api Key must have at least two characters'),
+}, {
+    invalid_type_error: 'Koala config must be an object with a publicApiKey property.',
+});
+var logrocketConfigInterfaceSchema = z.object({
+    appId: z.string({
+        required_error: 'Logrocket appId is missing.',
+        invalid_type_error: 'Logrocket appId must be a string.',
+    }),
+}, {
+    invalid_type_error: 'Logrocket config must be an object with an appId property.',
+});
+var mixpanelConfigInterfaceSchema = z.object({
+    projectToken: z.string({
+        required_error: 'Mixpanel projectToken is missing.',
+        invalid_type_error: 'Mixpanel projectToken must be a string.',
+    }),
+}, {
+    invalid_type_error: 'Mixpanel config must be an object with a projectToken property.',
+});
+var pirschConfigInterfaceSchema = z.object({
+    id: z.string({
+        required_error: 'Pirsch id is missing.',
+        invalid_type_error: 'Pirsch id must be a string.',
+    }),
+}, { invalid_type_error: 'Pirsch config must be an object with an id property.' });
+var postHogConfigInterfaceSchema = z.object({
+    apiKey: z
+        .string({
+        required_error: 'Posthog apiKey is missing.',
+        invalid_type_error: 'Posthog apiKey must be a string.',
+    })
+        .startsWith('phc_', 'Posthog apiKey must start with phc_'),
+    apiHost: z
+        .string({ invalid_type_error: 'Posthog apiHost must be a string.' })
+        .url('Posthog apiHost must be a valid URL.')
+        .optional(),
+}, {
+    invalid_type_error: 'Posthog config must be an object with an apiKey property.',
+});
+var plausibleConfigInterfaceSchema = z.object({
+    domain: z
+        .string({
+        required_error: 'Plausible domain is missing.',
+        invalid_type_error: 'Plausible domain must be a string.',
+    })
+        .refine(function (domain) { return !domain.startsWith('http://') && !domain.startsWith('https://'); }, 'Plausible domain must not start with http:// or https://'),
+}, {
+    invalid_type_error: 'Plausible config must be an object with a domain property. The domain must not start with http:// or https://.',
+});
+export var analyticsSchema = z
+    .object({
+    amplitude: amplitudeConfigInterfaceSchema.optional(),
+    clearbit: clearbitConfigInterfaceSchema.optional(),
+    fathom: fathomConfigInterfaceSchema.optional(),
+    ga4: googleAnalyticsConfigInterfaceSchema.optional(),
+    gtm: googleTagManagerConfigInterfaceSchema.optional(),
+    hotjar: hotjarConfigInterfaceSchema.optional(),
+    koala: koalaConfigInterfaceSchema.optional(),
+    logrocket: logrocketConfigInterfaceSchema.optional(),
+    mixpanel: mixpanelConfigInterfaceSchema.optional(),
+    pirsch: pirschConfigInterfaceSchema.optional(),
+    posthog: postHogConfigInterfaceSchema.optional(),
+    plausible: plausibleConfigInterfaceSchema.optional(),
+})
+    .strict('Mintlify only supports analytics integrations from: amplitude, clearbit, fathom, ga4, gtm, hotjar, koala, logrocket, mixpanel, pirsch, posthog and plausible.');

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

@@ -12,7 +12,6 @@ export declare const gradientSchema: z.ZodObject<{
     to: string;
     via?: string | undefined;
 }>;
-export type GradientType = z.infer<typeof gradientSchema>;
 export declare const anchorColorSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
     from: z.ZodString;
     via: z.ZodOptional<z.ZodString>;

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { hexadecimalPattern } from '../hexadecimalPattern.js';
+export var gradientSchema = z.object({
+    from: z
+        .string({
+        invalid_type_error: 'Anchor color.from must be a string.',
+    })
+        .regex(hexadecimalPattern, 'Anchor color.from must be a hexadecimal color.'),
+    via: z
+        .string({
+        invalid_type_error: 'Anchor color.via must be a string.',
+    })
+        .regex(hexadecimalPattern, 'Anchor color.via must be undefined or a hexadecimal color.')
+        .optional(),
+    to: z
+        .string({
+        invalid_type_error: 'Anchor color.to must be a string.',
+    })
+        .regex(hexadecimalPattern, 'Anchor color.to must be a hexadecimal color.'),
+});
+export var anchorColorSchema = z.union([
+    z
+        .string({ invalid_type_error: 'Anchor color must be a string.' })
+        .regex(hexadecimalPattern, 'Anchor color must be a hexadecimal color.'),
+    gradientSchema.strict('Anchors with gradient colors can only have properties from, via, and to with valid hexadecimal colors.'),
+], {
+    invalid_type_error: 'Anchor color must be a string or an object with from and to properties.',
+});

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-declare const anchorSchema: z.ZodObject<{
+export declare const anchorSchema: 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>;
@@ -23,7 +23,7 @@ declare const anchorSchema: 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;
@@ -35,7 +35,7 @@ declare const anchorSchema: 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;
@@ -44,65 +44,16 @@ declare const anchorSchema: z.ZodObject<{
     isDefaultHidden?: boolean | undefined;
     version?: string | undefined;
 }>;
-export declare const anchorsSchema: 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"]>>;
-    color: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        from: z.ZodString;
-        via: z.ZodOptional<z.ZodString>;
-        to: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        from: string;
-        to: string;
-        via?: string | undefined;
-    }, {
-        from: string;
-        to: string;
-        via?: string | undefined;
-    }>]>>;
-    isDefaultHidden: z.ZodOptional<z.ZodBoolean>;
-    version: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    url: string;
-    icon?: string | undefined;
-    iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
-    color?: string | {
-        from: string;
-        to: string;
-        via?: string | undefined;
-    } | undefined;
-    isDefaultHidden?: boolean | undefined;
-    version?: string | undefined;
-}, {
-    name: string;
-    url: string;
-    icon?: string | undefined;
-    iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
-    color?: string | {
-        from: string;
-        to: string;
-        via?: string | undefined;
-    } | undefined;
-    isDefaultHidden?: boolean | undefined;
-    version?: string | undefined;
-}>, "many">;
 export declare const topAnchorSchema: 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;
 }>;
-export type AnchorType = z.infer<typeof anchorSchema>;
-export type AnchorsType = z.infer<typeof anchorsSchema>;
-export type TopAnchorType = z.infer<typeof topAnchorSchema>;
-export {};

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

@@ -0,0 +1,69 @@
+import { iconTypes } from '@mintlify/models';
+import { z } from 'zod';
+import { anchorColorSchema } from './anchorColors.js';
+export var anchorSchema = z.object({
+    name: z
+        .string({
+        required_error: 'Every anchor must have a name.',
+        invalid_type_error: 'Anchor name must be a string.',
+    })
+        .trim()
+        .min(1, 'Anchor name is empty.'),
+    url: z
+        .string({
+        required_error: 'Every anchor must have a url',
+        invalid_type_error: 'Anchor url must be a string.',
+    })
+        .trim()
+        .min(1, 'Anchor URL is missing.'),
+    icon: z
+        .string({
+        invalid_type_error: 'Anchor icon must be the name of a Font Awesome icon. Visit this link to see all the available icons: https://fontawesome.com/icons',
+    })
+        .refine(function (iconStr) { return !iconStr.startsWith('fa-'); }, 'icon does not need to start with "fa-". Please delete "fa-" and keep the rest of the icon name.')
+        .optional(),
+    iconType: z
+        .enum(iconTypes, {
+        errorMap: function () {
+            return {
+                message: 'anchor iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
+            };
+        },
+    })
+        .optional(),
+    color: anchorColorSchema.optional(),
+    isDefaultHidden: z
+        .boolean({
+        invalid_type_error: 'Anchor isDefaultHidden must be a boolean. Try writing true or false without quotes around them.',
+    })
+        .optional(),
+    version: z
+        .string({
+        invalid_type_error: 'Version must be a string in the versions array.',
+    })
+        .optional(),
+});
+export var topAnchorSchema = z
+    .object({
+    name: z.string({
+        required_error: 'topAnchor.name is missing, set it or delete the entire topAnchor property.',
+        invalid_type_error: 'topAnchor.name must be a string',
+    }),
+    icon: z
+        .string({
+        invalid_type_error: 'topAnchor.icon must be a string',
+    })
+        .optional(),
+    iconType: z
+        .enum(iconTypes, {
+        errorMap: function () {
+            return {
+                message: 'topAnchor.iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
+            };
+        },
+    })
+        .optional(),
+}, {
+    invalid_type_error: "topAnchor must be an object with a name property. Delete the topAnchor if you don't want to customize the values.",
+})
+    .strict('topAnchor can only have name, icon, and iconType properties.');

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

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 export declare const openApiSchema: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
-export type OpenApiType = z.infer<typeof openApiSchema>;
 export declare const apiSchema: z.ZodObject<{
     baseUrl: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
     auth: z.ZodOptional<z.ZodObject<{
@@ -74,4 +73,3 @@ export declare const apiSchema: z.ZodObject<{
     } | undefined;
     maintainOrder?: boolean | undefined;
 }>;
-export type ApiConfigType = z.infer<typeof apiSchema>;

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export var 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 var 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(),
+    auth: z
+        .object({
+        method: z
+            .enum(['bearer', 'basic', 'key', 'cobo'], {
+            errorMap: function () {
+                return {
+                    message: 'api.auth.method has to be one of: bearer, basic, or key',
+                };
+            },
+        })
+            .optional(),
+        name: z.string().optional(),
+        inputPrefix: z.string().optional(),
+    })
+        .strict('api.auth can only contain method, name, and inputPrefix.')
+        .optional(),
+    playground: z
+        .object({
+        mode: z
+            .enum(['show', 'simple', 'hide'], {
+            errorMap: function () {
+                return {
+                    message: 'api.playground.mode must be one of the following strings: show, simple, or hide',
+                };
+            },
+        })
+            .optional()
+            .default('show'),
+    })
+        .optional(),
+    request: z
+        .object({
+        example: z
+            .object({
+            showOptionalParams: z.boolean().optional().default(false),
+        })
+            .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.',
+})
+    .strict('api can only contain baseUrl, auth, and playground as properties.');

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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { NavbarLinkType } from '../types/enums';
 export declare const nameSchema: z.ZodString;
 export declare const logoSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
     light: z.ZodString;
@@ -94,13 +93,3 @@ export declare const createCtaButtonSchema: (ctaButtonName: string) => z.ZodUnio
     type: "github";
     url: string;
 }>]>;
-export type LogoType = z.infer<typeof logoSchema>;
-export type FeedbackType = z.infer<typeof feedbackSchema>;
-export type FooterSocialsType = z.infer<typeof footerSocialsSchema>;
-export type NavbarLink = {
-    url: string;
-    type?: NavbarLinkType;
-    name?: string;
-};
-export declare const iconTypes: readonly ["brands", "duotone", "light", "regular", "sharp-solid", "solid", "thin"];
-export type IconType = (typeof iconTypes)[number];