@mintlify/validation 0.1.297 → 0.1.299

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

@@ -1,37 +1,37 @@
 import { z } from 'zod';
 import { LanguageNavigation } from './divisionNav.js';
 export declare const baseLanguageSchema: z.ZodObject<{
-    language: z.ZodEnum<["en", "cn", "es", "fr", "jp", "pt", "pt-BR", "de"]>;
+    language: z.ZodEnum<["en", "cn", "es", "fr", "jp", "pt", "pt-BR", "de", "ko"]>;
     default: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de";
+    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de" | "ko";
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }, {
-    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de";
+    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de" | "ko";
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }>;
 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.ZodObject<{
     default: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
-    language: z.ZodEnum<["en", "cn", "es", "fr", "jp", "pt", "pt-BR", "de"]>;
+    language: z.ZodEnum<["en", "cn", "es", "fr", "jp", "pt", "pt-BR", "de", "ko"]>;
     href: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     href: string;
-    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de";
+    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de" | "ko";
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }, {
     href: string;
-    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de";
+    language: "en" | "cn" | "es" | "fr" | "jp" | "pt" | "pt-BR" | "de" | "ko";
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }>;
+export declare const languageSchema: z.ZodType<LanguageNavigation<'default'>>;
+export declare const decoratedLanguageSchema: z.ZodType<LanguageNavigation<'decorated'>>;
 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

@@ -4,59 +4,73 @@ import { hrefSchema } from '../reusable/href.js';
 import { openApiSchema } from '../reusable/openapi.js';
 import { anchorsSchema, decoratedAnchorsSchema } from './anchors.js';
 import { decoratedDropdownsSchema, dropdownsSchema } from './dropdown.js';
+import { globalSchema } from './global.js';
 import { decoratedGroupsSchema, groupsSchema } from './groups.js';
 import { decoratedPagesSchema, pagesSchema } from './pages.js';
 import { decoratedTabsSchema, tabsSchema } from './tabs.js';
 import { decoratedVersionsSchema, versionsSchema } from './version.js';
 export const baseLanguageSchema = z.object({
     language: z
-        .enum(['en', 'cn', 'es', 'fr', 'jp', 'pt', 'pt-BR', 'de'])
+        .enum(['en', 'cn', 'es', 'fr', 'jp', 'pt', 'pt-BR', 'de', 'ko'])
         .describe('The name of the language in the ISO 639-1 format'),
     default: z.boolean().optional().describe('Whether this language is the default language'),
     hidden: hiddenSchema.optional(),
 });
+export const nonRecursiveLanguageSchema = baseLanguageSchema.extend({ href: hrefSchema });
 export const languageSchema = z
     .union([
-    baseLanguageSchema.extend({ href: hrefSchema, openapi: openApiSchema.optional() }),
+    baseLanguageSchema.extend({
+        href: hrefSchema,
+        openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
+    }),
     baseLanguageSchema.extend({
         versions: z.lazy(() => versionsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseLanguageSchema.extend({
         tabs: z.lazy(() => tabsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseLanguageSchema.extend({
         dropdowns: z.lazy(() => dropdownsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseLanguageSchema.extend({
         anchors: z.lazy(() => anchorsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseLanguageSchema.extend({
         groups: z.lazy(() => groupsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseLanguageSchema.extend({
         pages: z.lazy(() => pagesSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
+    }),
+    baseLanguageSchema.extend({
+        openapi: openApiSchema,
+        global: z.lazy(() => globalSchema).optional(),
     }),
-    baseLanguageSchema.extend({ openapi: openApiSchema }),
 ])
     .describe('Organizing by languages');
 export const decoratedLanguageSchema = baseLanguageSchema
     .and(z.union([
     z.object({ href: hrefSchema }),
-    z.lazy(() => z.object({ versions: decoratedVersionsSchema })),
-    z.lazy(() => z.object({ tabs: decoratedTabsSchema })),
-    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema })),
-    z.lazy(() => z.object({ anchors: decoratedAnchorsSchema })),
-    z.lazy(() => z.object({ groups: decoratedGroupsSchema })),
-    z.lazy(() => z.object({ pages: decoratedPagesSchema })),
+    z.lazy(() => z.object({ versions: decoratedVersionsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ tabs: decoratedTabsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ anchors: decoratedAnchorsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ groups: decoratedGroupsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ pages: decoratedPagesSchema, global: globalSchema.optional() })),
 ]))
     .describe('Organizing by languages');
-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

@@ -29,8 +29,6 @@ export declare const baseTabSchema: z.ZodObject<{
     hidden?: boolean | undefined;
 }>;
 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.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"]>>;
@@ -62,6 +60,8 @@ export declare const nonRecursiveTabSchema: z.ZodObject<{
     } | undefined;
     hidden?: boolean | undefined;
 }>;
+export declare const tabSchema: z.ZodType<TabNavigation<'default'>>;
+export declare const decoratedTabSchema: z.ZodType<TabNavigation<'decorated'>>;
 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

@@ -5,6 +5,7 @@ import { iconSchema } from '../reusable/icon.js';
 import { openApiSchema } from '../reusable/openapi.js';
 import { anchorsSchema, decoratedAnchorsSchema } from './anchors.js';
 import { decoratedDropdownsSchema, dropdownsSchema } from './dropdown.js';
+import { globalSchema } from './global.js';
 import { decoratedGroupsSchema, groupsSchema } from './groups.js';
 import { decoratedLanguagesSchema, languagesSchema } from './languages.js';
 import { decoratedPagesSchema, pagesSchema } from './pages.js';
@@ -14,44 +15,54 @@ export const baseTabSchema = z.object({
     icon: iconSchema.optional(),
     hidden: hiddenSchema.optional(),
 });
+export const nonRecursiveTabSchema = baseTabSchema.extend({ href: hrefSchema });
 export const tabSchema = z.union([
-    baseTabSchema.extend({ href: hrefSchema, openapi: openApiSchema.optional() }),
+    baseTabSchema.extend({
+        href: hrefSchema,
+        openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
+    }),
     baseTabSchema.extend({
         languages: z.lazy(() => languagesSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseTabSchema.extend({
         versions: z.lazy(() => versionsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseTabSchema.extend({
         dropdowns: z.lazy(() => dropdownsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseTabSchema.extend({
         anchors: z.lazy(() => anchorsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseTabSchema.extend({
         groups: z.lazy(() => groupsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseTabSchema.extend({
         pages: z.lazy(() => pagesSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
-    baseTabSchema.extend({ openapi: openApiSchema }),
+    baseTabSchema.extend({ openapi: openApiSchema, global: z.lazy(() => globalSchema).optional() }),
 ]);
 export const decoratedTabSchema = baseTabSchema.and(z.union([
     z.object({ href: hrefSchema }),
-    z.lazy(() => z.object({ languages: decoratedLanguagesSchema })),
-    z.lazy(() => z.object({ versions: decoratedVersionsSchema })),
-    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema })),
-    z.lazy(() => z.object({ anchors: decoratedAnchorsSchema })),
-    z.lazy(() => z.object({ groups: decoratedGroupsSchema })),
-    z.lazy(() => z.object({ pages: decoratedPagesSchema })),
+    z.lazy(() => z.object({ languages: decoratedLanguagesSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ versions: decoratedVersionsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ anchors: decoratedAnchorsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ groups: decoratedGroupsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ pages: decoratedPagesSchema, global: globalSchema.optional() })),
 ]));
-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

@@ -14,8 +14,6 @@ export declare const baseVersionSchema: z.ZodObject<{
     hidden?: boolean | undefined;
 }>;
 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.ZodObject<{
     version: z.ZodString;
     default: z.ZodOptional<z.ZodBoolean>;
@@ -32,6 +30,8 @@ export declare const nonRecursiveVersionSchema: z.ZodObject<{
     default?: boolean | undefined;
     hidden?: boolean | undefined;
 }>;
+export declare const versionSchema: z.ZodType<VersionNavigation<'default'>>;
+export declare const decoratedVersionSchema: z.ZodType<VersionNavigation<'decorated'>>;
 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

@@ -4,6 +4,7 @@ import { hrefSchema } from '../reusable/href.js';
 import { openApiSchema } from '../reusable/openapi.js';
 import { anchorsSchema, decoratedAnchorsSchema } from './anchors.js';
 import { decoratedDropdownsSchema, dropdownsSchema } from './dropdown.js';
+import { globalSchema } from './global.js';
 import { decoratedGroupsSchema, groupsSchema } from './groups.js';
 import { decoratedLanguagesSchema, languagesSchema } from './languages.js';
 import { decoratedPagesSchema, pagesSchema } from './pages.js';
@@ -13,44 +14,57 @@ export const baseVersionSchema = z.object({
     default: z.boolean().optional().describe('Whether this version is the default version'),
     hidden: hiddenSchema.optional(),
 });
+export const nonRecursiveVersionSchema = baseVersionSchema.extend({ href: hrefSchema });
 export const versionSchema = z.union([
-    baseVersionSchema.extend({ href: hrefSchema, openapi: openApiSchema.optional() }),
+    baseVersionSchema.extend({
+        href: hrefSchema,
+        openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
+    }),
     baseVersionSchema.extend({
         languages: z.lazy(() => languagesSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseVersionSchema.extend({
         tabs: z.lazy(() => tabsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseVersionSchema.extend({
         dropdowns: z.lazy(() => dropdownsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseVersionSchema.extend({
         anchors: z.lazy(() => anchorsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseVersionSchema.extend({
         groups: z.lazy(() => groupsSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
     }),
     baseVersionSchema.extend({
         pages: z.lazy(() => pagesSchema),
         openapi: openApiSchema.optional(),
+        global: z.lazy(() => globalSchema).optional(),
+    }),
+    baseVersionSchema.extend({
+        openapi: openApiSchema,
+        global: z.lazy(() => globalSchema).optional(),
     }),
-    baseVersionSchema.extend({ openapi: openApiSchema }),
 ]);
 export const decoratedVersionSchema = baseVersionSchema.and(z.union([
     z.object({ href: hrefSchema }),
-    z.lazy(() => z.object({ languages: decoratedLanguagesSchema })),
-    z.lazy(() => z.object({ tabs: decoratedTabsSchema })),
-    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema })),
-    z.lazy(() => z.object({ anchors: decoratedAnchorsSchema })),
-    z.lazy(() => z.object({ groups: decoratedGroupsSchema })),
-    z.lazy(() => z.object({ pages: decoratedPagesSchema })),
+    z.lazy(() => z.object({ languages: decoratedLanguagesSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ tabs: decoratedTabsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ dropdowns: decoratedDropdownsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ anchors: decoratedAnchorsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ groups: decoratedGroupsSchema, global: globalSchema.optional() })),
+    z.lazy(() => z.object({ pages: decoratedPagesSchema, global: globalSchema.optional() })),
 ]));
-export const nonRecursiveVersionSchema = baseVersionSchema.extend({ href: hrefSchema });
 export const versionsSchema = z
     .array(versionSchema)
     .min(1, 'At least one version must be specified')