@mintlify/validation 0.1.272 → 0.1.274

package/dist/mint-config/schemas/v2/properties/navigation/index.js

@@ -7,17 +7,17 @@ import { decoratedLanguagesSchema, languagesSchema, } from './languages.js';
 import { decoratedPagesSchema, pagesSchema } from './pages.js';
 import { decoratedTabsSchema, tabsSchema } from './tabs.js';
 import { decoratedVersionsSchema, versionsSchema, } from './version.js';
+const baseNavigationSchema = z.object({ global: globalSchema.optional() });
 export const navigationSchema = z
     .union([
-    z.object({ languages: languagesSchema }),
-    z.object({ versions: versionsSchema }),
-    z.object({ tabs: tabsSchema }),
-    z.object({ dropdowns: dropdownsSchema }),
-    z.object({ anchors: anchorsSchema }),
-    z.object({ groups: groupsSchema }),
-    z.object({ pages: pagesSchema }),
+    baseNavigationSchema.extend({ languages: languagesSchema }),
+    baseNavigationSchema.extend({ versions: versionsSchema }),
+    baseNavigationSchema.extend({ tabs: tabsSchema }),
+    baseNavigationSchema.extend({ dropdowns: dropdownsSchema }),
+    baseNavigationSchema.extend({ anchors: anchorsSchema }),
+    baseNavigationSchema.extend({ groups: groupsSchema }),
+    baseNavigationSchema.extend({ pages: pagesSchema }),
 ])
-    .and(z.object({ global: globalSchema.optional() }))
     .describe('The navigation structure of the content');
 export const decoratedNavigationSchema = z
     .union([

package/dist/mint-config/schemas/v2/properties/navigation/languages.d.ts

@@ -16,25 +16,22 @@ export declare const baseLanguageSchema: z.ZodObject<{
 export type BaseLanguageSchema = z.infer<typeof baseLanguageSchema>;
 export declare const languageSchema: z.ZodType<LanguageNavigation<'default'>>;
 export declare const decoratedLanguageSchema: z.ZodType<LanguageNavigation<'decorated'>>;
-export declare const nonRecursiveLanguageSchema: z.ZodIntersection<z.ZodObject<{
-    language: z.ZodEnum<["en", "cn", "es", "fr", "jp", "pt", "pt-BR", "de"]>;
+export declare const nonRecursiveLanguageSchema: z.ZodObject<{
     default: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
+    language: z.ZodEnum<["en", "cn", "es", "fr", "jp", "pt", "pt-BR", "de"]>;
+    href: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    href: string;
     language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de";
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }, {
+    href: string;
     language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de";
     default?: boolean | undefined;
     hidden?: boolean | undefined;
-}>, z.ZodObject<{
-    href: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    href: string;
-}, {
-    href: string;
-}>>;
+}>;
 export declare const languagesSchema: z.ZodArray<z.ZodType<LanguageNavigation<"default">, z.ZodTypeDef, LanguageNavigation<"default">>, "many">;
 export declare const decoratedLanguagesSchema: z.ZodArray<z.ZodType<LanguageNavigation<"decorated">, z.ZodTypeDef, LanguageNavigation<"decorated">>, "many">;
 export type LanguagesConfig = z.infer<typeof languagesSchema>;

package/dist/mint-config/schemas/v2/properties/navigation/languages.js

@@ -56,7 +56,7 @@ export const decoratedLanguageSchema = baseLanguageSchema
     z.lazy(() => z.object({ pages: decoratedPagesSchema })),
 ]))
     .describe('Organizing by languages');
-export const nonRecursiveLanguageSchema = baseLanguageSchema.and(z.object({ href: hrefSchema }));
+export const nonRecursiveLanguageSchema = baseLanguageSchema.extend({ href: hrefSchema });
 export const languagesSchema = z
     .array(languageSchema)
     .min(1, 'At least one language must be specified')

package/dist/mint-config/schemas/v2/properties/navigation/tabs.d.ts

@@ -31,8 +31,7 @@ export declare const baseTabSchema: z.ZodObject<{
 export type BaseTabSchema = z.infer<typeof baseTabSchema>;
 export declare const tabSchema: z.ZodType<TabNavigation<'default'>>;
 export declare const decoratedTabSchema: z.ZodType<TabNavigation<'decorated'>>;
-export declare const nonRecursiveTabSchema: z.ZodIntersection<z.ZodObject<{
-    tab: z.ZodString;
+export declare const nonRecursiveTabSchema: z.ZodObject<{
     icon: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodObject<{
         style: z.ZodOptional<z.ZodEnum<["brands", "duotone", "light", "regular", "sharp-duotone-solid", "sharp-light", "sharp-regular", "sharp-solid", "sharp-thin", "solid", "thin"]>>;
         name: z.ZodEffects<z.ZodString, string, string>;
@@ -44,7 +43,10 @@ export declare const nonRecursiveTabSchema: z.ZodIntersection<z.ZodObject<{
         style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
     }>]>>;
     hidden: z.ZodOptional<z.ZodBoolean>;
+    tab: z.ZodString;
+    href: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    href: string;
     tab: string;
     icon?: string | {
         name: string;
@@ -52,19 +54,14 @@ export declare const nonRecursiveTabSchema: z.ZodIntersection<z.ZodObject<{
     } | undefined;
     hidden?: boolean | undefined;
 }, {
+    href: string;
     tab: string;
     icon?: string | {
         name: string;
         style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
     } | undefined;
     hidden?: boolean | undefined;
-}>, z.ZodObject<{
-    href: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    href: string;
-}, {
-    href: string;
-}>>;
+}>;
 export declare const tabsSchema: z.ZodArray<z.ZodType<TabNavigation<"default">, z.ZodTypeDef, TabNavigation<"default">>, "many">;
 export declare const decoratedTabsSchema: z.ZodArray<z.ZodType<TabNavigation<"decorated">, z.ZodTypeDef, TabNavigation<"decorated">>, "many">;
 export type TabsConfig = z.infer<typeof tabsSchema>;

package/dist/mint-config/schemas/v2/properties/navigation/tabs.js

@@ -51,7 +51,7 @@ export const decoratedTabSchema = baseTabSchema.and(z.union([
     z.lazy(() => z.object({ groups: decoratedGroupsSchema })),
     z.lazy(() => z.object({ pages: decoratedPagesSchema })),
 ]));
-export const nonRecursiveTabSchema = baseTabSchema.and(z.object({ href: hrefSchema }));
+export const nonRecursiveTabSchema = baseTabSchema.extend({ href: hrefSchema });
 export const tabsSchema = z
     .array(tabSchema)
     .min(1, 'At least one tab must be specified')

package/dist/mint-config/schemas/v2/properties/navigation/version.d.ts

@@ -16,25 +16,22 @@ export declare const baseVersionSchema: z.ZodObject<{
 export type BaseVersionSchema = z.infer<typeof baseVersionSchema>;
 export declare const versionSchema: z.ZodType<VersionNavigation<'default'>>;
 export declare const decoratedVersionSchema: z.ZodType<VersionNavigation<'decorated'>>;
-export declare const nonRecursiveVersionSchema: z.ZodIntersection<z.ZodObject<{
+export declare const nonRecursiveVersionSchema: z.ZodObject<{
     version: z.ZodString;
     default: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
+    href: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     version: string;
+    href: string;
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }, {
     version: string;
+    href: string;
     default?: boolean | undefined;
     hidden?: boolean | undefined;
-}>, z.ZodObject<{
-    href: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    href: string;
-}, {
-    href: string;
-}>>;
+}>;
 export declare const versionsSchema: z.ZodArray<z.ZodType<VersionNavigation<"default">, z.ZodTypeDef, VersionNavigation<"default">>, "many">;
 export declare const decoratedVersionsSchema: z.ZodArray<z.ZodType<VersionNavigation<"decorated">, z.ZodTypeDef, VersionNavigation<"decorated">>, "many">;
 export type VersionsConfig = z.infer<typeof versionsSchema>;

package/dist/mint-config/schemas/v2/properties/navigation/version.js

@@ -50,7 +50,7 @@ export const decoratedVersionSchema = baseVersionSchema.and(z.union([
     z.lazy(() => z.object({ groups: decoratedGroupsSchema })),
     z.lazy(() => z.object({ pages: decoratedPagesSchema })),
 ]));
-export const nonRecursiveVersionSchema = baseVersionSchema.and(z.object({ href: hrefSchema }));
+export const nonRecursiveVersionSchema = baseVersionSchema.extend({ href: hrefSchema });
 export const versionsSchema = z
     .array(versionSchema)
     .min(1, 'At least one version must be specified')