@mintlify/validation 0.1.59 → 0.1.61

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { MintValidationResults } from './mint-config/common';
-import type { ConfigType } from './mint-config/types';
+import type { ConfigType } from '@mintlify/models';
+import { MintValidationResults } from './mint-config/common.js';
 export declare function validateMintConfig(config: ConfigType): MintValidationResults;
-export * from './openapi/types/endpoint';
-export * from './mint-config/types';
-export { convertOpenAPIV3_1ToEndpoint } from './openapi/convertOpenApi';
-export { convertSchema } from './openapi/convertSchema';
+export * from './openapi/types/endpoint.js';
+export { convertOpenAPIV3_1ToEndpoint } from './openapi/convertOpenApi.js';
+export { convertSchema } from './openapi/convertSchema.js';
 export declare const mintConfigSchema: any;

package/dist/index.js

@@ -1,18 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 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)) {
@@ -22,39 +7,34 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mintConfigSchema = exports.convertSchema = exports.convertOpenAPIV3_1ToEndpoint = exports.validateMintConfig = void 0;
-var zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-var common_1 = require("./mint-config/common");
-var flattenUnionErrorMessages_1 = require("./mint-config/flattenUnionErrorMessages");
-var config_1 = require("./mint-config/schemas/config");
-var validateAnchorsWarnings_1 = require("./mint-config/validateAnchorsWarnings");
-var validateVersionsInNavigation_1 = require("./mint-config/validateVersionsInNavigation");
-function validateMintConfig(config) {
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { MintValidationResults } from './mint-config/common.js';
+import { flattenUnionErrorMessages } from './mint-config/flattenUnionErrorMessages.js';
+import { configSchema } from './mint-config/schemas/config.js';
+import { validateAnchorsWarnings } from './mint-config/validateAnchorsWarnings.js';
+import { validateVersionsInNavigation } from './mint-config/validateVersionsInNavigation.js';
+export function validateMintConfig(config) {
     var _a;
-    var results = new common_1.MintValidationResults();
+    var results = new MintValidationResults();
     if (config == null || config == undefined || Object.entries(config).length === 0) {
         results.errors.push('Mint Config object cannot be empty.');
         results.status = 'error';
         return results;
     }
     // Specific warnings and errors
-    var validateAnchorsWarningResult = (0, validateAnchorsWarnings_1.validateAnchorsWarnings)(config.anchors, config.navigation);
-    var validateVersionsInNavigationResult = (0, validateVersionsInNavigation_1.validateVersionsInNavigation)(config.navigation, (_a = config.versions) !== null && _a !== void 0 ? _a : []);
+    var validateAnchorsWarningResult = validateAnchorsWarnings(config.anchors, config.navigation);
+    var validateVersionsInNavigationResult = validateVersionsInNavigation(config.navigation, (_a = config.versions) !== null && _a !== void 0 ? _a : []);
     results.errors = __spreadArray(__spreadArray([], results.errors, true), validateVersionsInNavigationResult.errors, true);
     results.warnings = __spreadArray(__spreadArray(__spreadArray([], results.warnings, true), validateVersionsInNavigationResult.warnings, true), validateAnchorsWarningResult.warnings, true);
     // Global check
-    var validateConfigResult = config_1.configSchema.safeParse(config);
+    var validateConfigResult = configSchema.safeParse(config);
     if (validateConfigResult.success == false) {
         var errors = validateConfigResult.error.issues;
         errors.forEach(function (e) {
             var _a;
             var _b;
             if (e.code === 'invalid_union' && ((_b = e.unionErrors) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                (_a = results.errors).push.apply(_a, (0, flattenUnionErrorMessages_1.flattenUnionErrorMessages)(e.unionErrors));
+                (_a = results.errors).push.apply(_a, flattenUnionErrorMessages(e.unionErrors));
             }
             else {
                 var message = e.message;
@@ -69,16 +49,12 @@ function validateMintConfig(config) {
     results.status = results.errors.length ? 'error' : 'success';
     return results;
 }
-exports.validateMintConfig = validateMintConfig;
-__exportStar(require("./openapi/types/endpoint"), exports);
-__exportStar(require("./mint-config/types"), exports);
-var convertOpenApi_1 = require("./openapi/convertOpenApi");
-Object.defineProperty(exports, "convertOpenAPIV3_1ToEndpoint", { enumerable: true, get: function () { return convertOpenApi_1.convertOpenAPIV3_1ToEndpoint; } });
-var convertSchema_1 = require("./openapi/convertSchema");
-Object.defineProperty(exports, "convertSchema", { enumerable: true, get: function () { return convertSchema_1.convertSchema; } });
-exports.mintConfigSchema = (function () {
+export * from './openapi/types/endpoint.js';
+export { convertOpenAPIV3_1ToEndpoint } from './openapi/convertOpenApi.js';
+export { convertSchema } from './openapi/convertSchema.js';
+export var mintConfigSchema = (function () {
     var _a, _b, _c, _d, _e, _f;
-    var schema = (0, zod_to_json_schema_1.default)(config_1.configSchema, 'Schema');
+    var schema = zodToJsonSchema(configSchema, 'Schema');
     (_b = (_a = schema.definitions) === null || _a === void 0 ? void 0 : _a.Schema) === null || _b === void 0 ? true : delete _b.properties.__injected;
     (_d = (_c = schema.definitions) === null || _c === void 0 ? void 0 : _c.Schema) === null || _d === void 0 ? true : delete _d.properties.colors.properties.ultraDark;
     (_f = (_e = schema.definitions) === null || _e === void 0 ? void 0 : _e.Schema) === null || _f === void 0 ? true : delete _f.properties.colors.properties.ultraLight;

package/dist/mint-config/common.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MintValidationResults = void 0;
 var MintValidationResults = /** @class */ (function () {
     function MintValidationResults() {
         this.status = 'success';
@@ -9,4 +6,4 @@ var MintValidationResults = /** @class */ (function () {
     }
     return MintValidationResults;
 }());
-exports.MintValidationResults = MintValidationResults;
+export { MintValidationResults };

package/dist/mint-config/flattenUnionErrorMessages.js

@@ -1,4 +1,3 @@
-"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)) {
@@ -8,11 +7,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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) {
+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);
@@ -20,4 +17,3 @@ function flattenUnionErrorMessages(unionErrors) {
         return __spreadArray(__spreadArray([], acc, true), [unionError.message], false);
     }, []);
 }
-exports.flattenUnionErrorMessages = flattenUnionErrorMessages;

package/dist/mint-config/hexadecimalPattern.js

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

@@ -1,33 +1,30 @@
-"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({
+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 = zod_1.z.object({
-    publicApiKey: zod_1.z.string({
+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 = zod_1.z.object({
-    siteId: zod_1.z.string({
+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 = zod_1.z.object({
-    measurementId: zod_1.z
+var googleAnalyticsConfigInterfaceSchema = z.object({
+    measurementId: z
         .string({
         required_error: 'Google Analytics measurementId is missing.',
         invalid_type_error: 'Google Analytics measurementId must be a string.',
@@ -36,8 +33,8 @@ var googleAnalyticsConfigInterfaceSchema = zod_1.z.object({
 }, {
     invalid_type_error: 'Google Analytics config must be an object with a measurementId property.',
 });
-var googleTagManagerConfigInterfaceSchema = zod_1.z.object({
-    tagId: zod_1.z
+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.',
@@ -46,20 +43,20 @@ var googleTagManagerConfigInterfaceSchema = zod_1.z.object({
 }, {
     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({
+var hotjarConfigInterfaceSchema = z.object({
+    hjid: z.string({
         required_error: 'Hotjar hjid is missing.',
         invalid_type_error: 'Hotjar hjid must be a string.',
     }),
-    hjsv: zod_1.z.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 = zod_1.z.object({
-    publicApiKey: zod_1.z
+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.',
@@ -68,44 +65,44 @@ var koalaConfigInterfaceSchema = zod_1.z.object({
 }, {
     invalid_type_error: 'Koala config must be an object with a publicApiKey property.',
 });
-var logrocketConfigInterfaceSchema = zod_1.z.object({
-    appId: zod_1.z.string({
+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 = zod_1.z.object({
-    projectToken: zod_1.z.string({
+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 = zod_1.z.object({
-    id: zod_1.z.string({
+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 = zod_1.z.object({
-    apiKey: zod_1.z
+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: zod_1.z
+    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 = zod_1.z.object({
-    domain: zod_1.z
+var plausibleConfigInterfaceSchema = z.object({
+    domain: z
         .string({
         required_error: 'Plausible domain is missing.',
         invalid_type_error: 'Plausible domain must be a string.',
@@ -114,7 +111,7 @@ var plausibleConfigInterfaceSchema = zod_1.z.object({
 }, {
     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
+export var analyticsSchema = z
     .object({
     amplitude: amplitudeConfigInterfaceSchema.optional(),
     clearbit: clearbitConfigInterfaceSchema.optional(),

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

@@ -1,31 +1,28 @@
-"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
+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_1.hexadecimalPattern, 'Anchor color.from must be a hexadecimal color.'),
-    via: zod_1.z
+        .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_1.hexadecimalPattern, 'Anchor color.via must be undefined or a hexadecimal color.')
+        .regex(hexadecimalPattern, 'Anchor color.via must be undefined or a hexadecimal color.')
         .optional(),
-    to: zod_1.z
+    to: z
         .string({
         invalid_type_error: 'Anchor color.to must be a string.',
     })
-        .regex(hexadecimalPattern_1.hexadecimalPattern, 'Anchor color.to must be a hexadecimal color.'),
+        .regex(hexadecimalPattern, 'Anchor color.to must be a hexadecimal color.'),
 });
-exports.anchorColorSchema = zod_1.z.union([
-    zod_1.z
+export var anchorColorSchema = z.union([
+    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.'),
+        .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?: "brands" | "duotone" | "light" | "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?: "brands" | "duotone" | "light" | "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?: "brands" | "duotone" | "light" | "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?: "brands" | "duotone" | "light" | "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?: "brands" | "duotone" | "light" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
 }, {
     name: string;
     icon?: string | undefined;
-    iconType?: "brands" | "duotone" | "light" | "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

@@ -1,31 +1,29 @@
-"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
+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: zod_1.z
+    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: zod_1.z
+    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: zod_1.z
-        .enum(['brands', 'duotone', 'light', 'sharp-solid', 'solid', 'thin'], {
+    iconType: z
+        .enum(iconTypes, {
         errorMap: function () {
             return {
                 message: 'anchor iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
@@ -33,32 +31,31 @@ var anchorSchema = zod_1.z.object({
         },
     })
         .optional(),
-    color: anchorColors_1.anchorColorSchema.optional(),
-    isDefaultHidden: zod_1.z
+    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: zod_1.z
+    version: z
         .string({
         invalid_type_error: 'Version must be a string in the versions array.',
     })
         .optional(),
 });
-exports.anchorsSchema = anchorSchema.array();
-exports.topAnchorSchema = zod_1.z
+export var topAnchorSchema = z
     .object({
-    name: zod_1.z.string({
+    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: zod_1.z
+    icon: z
         .string({
         invalid_type_error: 'topAnchor.icon must be a string',
     })
         .optional(),
-    iconType: zod_1.z
-        .enum(['brands', 'duotone', 'light', 'sharp-solid', 'solid', 'thin'], {
+    iconType: z
+        .enum(iconTypes, {
         errorMap: function () {
             return {
                 message: 'topAnchor.iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',

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>;