@mintlify/validation 0.1.58 → 0.1.59

package/dist/mint-config/common.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MintValidationResults = void 0;
+var MintValidationResults = /** @class */ (function () {
+    function MintValidationResults() {
+        this.status = 'success';
+        this.errors = [];
+        this.warnings = [];
+    }
+    return MintValidationResults;
+}());
+exports.MintValidationResults = MintValidationResults;

package/dist/mint-config/flattenUnionErrorMessages.js

@@ -0,0 +1,23 @@
+"use strict";
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenUnionErrorMessages = void 0;
+// TO DO: Write unit tests for this function.
+// TO DO: Prettify the output instead of just returning JSON objects.
+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);
+    }, []);
+}
+exports.flattenUnionErrorMessages = flattenUnionErrorMessages;

package/dist/mint-config/hexadecimalPattern.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexadecimalPattern = void 0;
+exports.hexadecimalPattern = /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsSchema = void 0;
+var zod_1 = require("zod");
+var amplitudeConfigInterfaceSchema = zod_1.z.object({
+    apiKey: zod_1.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 = zod_1.z.object({
+    publicApiKey: zod_1.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 = zod_1.z.object({
+    siteId: zod_1.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 = zod_1.z.object({
+    measurementId: zod_1.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 = zod_1.z.object({
+    tagId: zod_1.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 = zod_1.z.object({
+    hjid: zod_1.z.string({
+        required_error: 'Hotjar hjid is missing.',
+        invalid_type_error: 'Hotjar hjid must be a string.',
+    }),
+    hjsv: zod_1.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 = zod_1.z.object({
+    publicApiKey: zod_1.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 = zod_1.z.object({
+    appId: zod_1.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 = zod_1.z.object({
+    projectToken: zod_1.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 = zod_1.z.object({
+    id: zod_1.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 = zod_1.z.object({
+    apiKey: zod_1.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: zod_1.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 = zod_1.z.object({
+    domain: zod_1.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://.',
+});
+exports.analyticsSchema = zod_1.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.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorColorSchema = exports.gradientSchema = void 0;
+var zod_1 = require("zod");
+var hexadecimalPattern_1 = require("../hexadecimalPattern");
+exports.gradientSchema = zod_1.z.object({
+    from: zod_1.z
+        .string({
+        invalid_type_error: 'Anchor color.from must be a string.',
+    })
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Anchor color.from must be a hexadecimal color.'),
+    via: zod_1.z
+        .string({
+        invalid_type_error: 'Anchor color.via must be a string.',
+    })
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Anchor color.via must be undefined or a hexadecimal color.')
+        .optional(),
+    to: zod_1.z
+        .string({
+        invalid_type_error: 'Anchor color.to must be a string.',
+    })
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Anchor color.to must be a hexadecimal color.'),
+});
+exports.anchorColorSchema = zod_1.z.union([
+    zod_1.z
+        .string({ invalid_type_error: 'Anchor color must be a string.' })
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Anchor color must be a hexadecimal color.'),
+    exports.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

@@ -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" | "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" | "sharp-solid" | "solid" | "thin" | undefined;
     color?: string | {
         from: string;
         to: string;
@@ -68,7 +68,7 @@ export declare const anchorsSchema: z.ZodArray<z.ZodObject<{
     name: string;
     url: string;
     icon?: string | undefined;
-    iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
     color?: string | {
         from: string;
         to: string;
@@ -80,7 +80,7 @@ export declare const anchorsSchema: z.ZodArray<z.ZodObject<{
     name: string;
     url: string;
     icon?: string | undefined;
-    iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
     color?: string | {
         from: string;
         to: string;
@@ -96,11 +96,11 @@ export declare const topAnchorSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     name: string;
     icon?: string | undefined;
-    iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
 }, {
     name: string;
     icon?: string | undefined;
-    iconType?: "light" | "brands" | "duotone" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
 }>;
 export type AnchorType = z.infer<typeof anchorSchema>;
 export type AnchorsType = z.infer<typeof anchorsSchema>;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topAnchorSchema = exports.anchorsSchema = void 0;
+var zod_1 = require("zod");
+var anchorColors_1 = require("./anchorColors");
+var anchorSchema = zod_1.z.object({
+    name: zod_1.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: zod_1.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: zod_1.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: zod_1.z
+        .enum(['brands', 'duotone', 'light', 'sharp-solid', 'solid', 'thin'], {
+        errorMap: function () {
+            return {
+                message: 'anchor iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
+            };
+        },
+    })
+        .optional(),
+    color: anchorColors_1.anchorColorSchema.optional(),
+    isDefaultHidden: zod_1.z
+        .boolean({
+        invalid_type_error: 'Anchor isDefaultHidden must be a boolean. Try writing true or false without quotes around them.',
+    })
+        .optional(),
+    version: zod_1.z
+        .string({
+        invalid_type_error: 'Version must be a string in the versions array.',
+    })
+        .optional(),
+});
+exports.anchorsSchema = anchorSchema.array();
+exports.topAnchorSchema = zod_1.z
+    .object({
+    name: zod_1.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: zod_1.z
+        .string({
+        invalid_type_error: 'topAnchor.icon must be a string',
+    })
+        .optional(),
+    iconType: zod_1.z
+        .enum(['brands', 'duotone', 'light', 'sharp-solid', 'solid', 'thin'], {
+        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.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiSchema = exports.openApiSchema = void 0;
+var zod_1 = require("zod");
+exports.openApiSchema = zod_1.z.union([
+    zod_1.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.',
+    }),
+    zod_1.z.array(zod_1.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.',
+    })),
+]);
+exports.apiSchema = zod_1.z
+    .object({
+    baseUrl: zod_1.z
+        .union([
+        zod_1.z.string().url('api.baseUrl must be a valid URL.'),
+        zod_1.z.array(zod_1.z.string().url('api.baseUrl array entries must be valid URLs.')),
+    ])
+        .optional(),
+    auth: zod_1.z
+        .object({
+        method: zod_1.z
+            .enum(['bearer', 'basic', 'key', 'cobo'], {
+            errorMap: function () {
+                return {
+                    message: 'api.auth.method has to be one of: bearer, basic, or key',
+                };
+            },
+        })
+            .optional(),
+        name: zod_1.z.string().optional(),
+        inputPrefix: zod_1.z.string().optional(),
+    })
+        .strict('api.auth can only contain method, name, and inputPrefix.')
+        .optional(),
+    playground: zod_1.z
+        .object({
+        mode: zod_1.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: zod_1.z
+        .object({
+        example: zod_1.z
+            .object({
+            showOptionalParams: zod_1.z.boolean().optional().default(false),
+        })
+            .optional(),
+    })
+        .optional(),
+    maintainOrder: zod_1.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.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iconTypes = exports.createCtaButtonSchema = exports.redirectsSchema = exports.searchSchema = exports.feedbackSchema = exports.footerSocialsSchema = exports.metadataSchema = exports.isWhiteLabeledSchema = exports.modeToggleSchema = exports.logoSchema = exports.nameSchema = void 0;
+var zod_1 = require("zod");
+exports.nameSchema = zod_1.z
+    .string({ required_error: 'Name is missing.' })
+    .min(1, 'Name cannot be empty.')
+    .trim();
+exports.logoSchema = zod_1.z.union([
+    zod_1.z.string().min(3, 'Logo needs to be a path to your logo file including the file extension.'),
+    zod_1.z.object({
+        light: zod_1.z.string(),
+        dark: zod_1.z.string(),
+        href: zod_1.z.string().optional(),
+    }),
+], {
+    invalid_type_error: 'Logo must be a string or an object with light and dark properties.',
+});
+exports.modeToggleSchema = zod_1.z.object({
+    default: zod_1.z
+        .enum(['light', 'dark'], {
+        errorMap: function () {
+            return {
+                message: 'modeToggleSchema.default must be one of the following: light or dark',
+            };
+        },
+    })
+        .optional(),
+    isHidden: zod_1.z
+        .boolean({
+        invalid_type_error: 'isHidden must be a boolean. Try writing true or false without the quotes.',
+    })
+        .optional(),
+});
+exports.isWhiteLabeledSchema = zod_1.z.boolean({
+    invalid_type_error: 'isWhiteLabeled must be a boolean. Try writing true or false without the quotes.',
+});
+exports.metadataSchema = zod_1.z.record(zod_1.z.string({ invalid_type_error: 'metadata keys must be strings' }), zod_1.z
+    .string({ invalid_type_error: 'metadata values must be strings' })
+    .min(1, 'metadata values must not be empty'));
+exports.footerSocialsSchema = zod_1.z.union([
+    // TO DO: deprecate array types
+    zod_1.z.array(zod_1.z.object({
+        type: zod_1.z.string(),
+        url: zod_1.z.string().url('footerSocials url must be a valid url'),
+    })),
+    zod_1.z.record(zod_1.z.string().trim().min(1, 'footerSocials name (the key in the object) must not be empty'), zod_1.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" }',
+});
+exports.feedbackSchema = zod_1.z.object({
+    thumbsRating: zod_1.z
+        .boolean({
+        invalid_type_error: 'thumbsRating must be a boolean. Try writing true or false without the quotes.',
+    })
+        .optional(),
+    suggestEdit: zod_1.z
+        .boolean({
+        invalid_type_error: 'suggestEdit must be a boolean. Try writing true or false without the quotes.',
+    })
+        .optional(),
+    raiseIssue: zod_1.z
+        .boolean({
+        invalid_type_error: 'raiseIssue must be a boolean. Try writing true or false without the quotes.',
+    })
+        .optional(),
+});
+exports.searchSchema = zod_1.z.object({
+    prompt: zod_1.z
+        .string({
+        invalid_type_error: 'search.prompt must be a string. If this field is undefined, the default prompt is `Search...`',
+    })
+        .optional(),
+});
+var redirectSchema = zod_1.z.object({
+    source: zod_1.z.string(),
+    destination: zod_1.z.string(),
+});
+exports.redirectsSchema = zod_1.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.',
+});
+var createCtaButtonSchema = function (ctaButtonName) {
+    return zod_1.z.union([
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('link').optional(),
+            name: zod_1.z.string({
+                required_error: 'Name must be defined when using a CTA button',
+                invalid_type_error: 'Name must be a string',
+            }),
+            url: zod_1.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.'),
+        zod_1.z
+            .object({
+            type: zod_1.z.literal('github'),
+            url: zod_1.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.',
+    });
+};
+exports.createCtaButtonSchema = createCtaButtonSchema;
+exports.iconTypes = [
+    'brands',
+    'duotone',
+    'light',
+    'regular',
+    'sharp-solid',
+    'solid',
+    'thin',
+];

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorsSchema = void 0;
+var zod_1 = require("zod");
+var hexadecimalPattern_1 = require("../hexadecimalPattern");
+var anchorColors_1 = require("./anchorColors");
+exports.colorsSchema = zod_1.z
+    .object({
+    primary: zod_1.z
+        .string({ invalid_type_error: 'Primary color must be a string.' })
+        .min(1, 'Color primary is missing.')
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Primary color must be a hexadecimal color including the # at the start.'),
+    light: zod_1.z
+        .string({ invalid_type_error: 'Light color must be a string.' })
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Light color must be a hexadecimal color including the # at the start.')
+        .optional(),
+    dark: zod_1.z
+        .string({ invalid_type_error: 'Dark color must be a string.' })
+        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Dark color must be a hexadecimal color including the # at the start.')
+        .optional(),
+    background: zod_1.z
+        .object({
+        light: zod_1.z
+            .string({
+            invalid_type_error: 'Background light color must be a string.',
+        })
+            .regex(hexadecimalPattern_1.hexadecimalPattern, 'Background light color must be a hexadecimal color including the # at the start.')
+            .optional(),
+        dark: zod_1.z
+            .string({
+            invalid_type_error: 'Background dark color must be a string.',
+        })
+            .regex(hexadecimalPattern_1.hexadecimalPattern, 'Background dark color must be a hexadecimal color including the # at the start.')
+            .optional(),
+    })
+        .optional(),
+    anchors: anchorColors_1.anchorColorSchema.optional(),
+    // Prevent strict() from throwing an error when the user defines a deprecated ultraLight / ultraDark color.
+    ultraLight: zod_1.z.any().optional(),
+    ultraDark: zod_1.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.');