@mintlify/validation 0.1.245 → 0.1.247

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

@@ -1,11 +1,13 @@
 import { z } from 'zod';
+import { lindenConfigSchema } from './themes/linden.js';
+import { mapleConfigSchema } from './themes/maple.js';
 import { mintConfigSchema } from './themes/mint.js';
-import { prismConfigSchema } from './themes/prism.js';
-import { quillConfigSchema } from './themes/quill.js';
-import { venusConfigSchema } from './themes/venus.js';
+import { palmConfigSchema } from './themes/palm.js';
+import { willowConfigSchema } from './themes/willow.js';
 export const docsConfigSchema = z.discriminatedUnion('theme', [
     mintConfigSchema,
-    prismConfigSchema,
-    quillConfigSchema,
-    venusConfigSchema,
+    mapleConfigSchema,
+    palmConfigSchema,
+    willowConfigSchema,
+    lindenConfigSchema,
 ]);

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

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 export declare const apiSchema: z.ZodObject<{
+    openapi: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">]>>;
     playground: z.ZodOptional<z.ZodObject<{
-        display: z.ZodDefault<z.ZodOptional<z.ZodEnum<["interactive", "simple", "none"]>>>;
-        proxy: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        display: z.ZodOptional<z.ZodEnum<["interactive", "simple", "none"]>>;
+        proxy: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
-        display: "simple" | "none" | "interactive";
-        proxy: boolean;
+        display?: "simple" | "none" | "interactive" | undefined;
+        proxy?: boolean | undefined;
     }, {
         display?: "simple" | "none" | "interactive" | undefined;
         proxy?: boolean | undefined;
@@ -19,27 +20,29 @@ export declare const apiSchema: z.ZodObject<{
     }>>;
     mdx: z.ZodOptional<z.ZodObject<{
         auth: z.ZodOptional<z.ZodEnum<["bearer", "basic", "key", "cobo"]>>;
-        base: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        server: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
     }, "strip", z.ZodTypeAny, {
         auth?: "key" | "bearer" | "basic" | "cobo" | undefined;
-        base?: string | string[] | undefined;
+        server?: string | string[] | undefined;
     }, {
         auth?: "key" | "bearer" | "basic" | "cobo" | undefined;
-        base?: string | string[] | undefined;
+        server?: string | string[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    openapi?: string | string[] | undefined;
     playground?: {
-        display: "simple" | "none" | "interactive";
-        proxy: boolean;
+        display?: "simple" | "none" | "interactive" | undefined;
+        proxy?: boolean | undefined;
     } | undefined;
     examples?: {
         languages?: string[] | undefined;
     } | undefined;
     mdx?: {
         auth?: "key" | "bearer" | "basic" | "cobo" | undefined;
-        base?: string | string[] | undefined;
+        server?: string | string[] | undefined;
     } | undefined;
 }, {
+    openapi?: string | string[] | undefined;
     playground?: {
         display?: "simple" | "none" | "interactive" | undefined;
         proxy?: boolean | undefined;
@@ -49,6 +52,6 @@ export declare const apiSchema: z.ZodObject<{
     } | undefined;
     mdx?: {
         auth?: "key" | "bearer" | "basic" | "cobo" | undefined;
-        base?: string | string[] | undefined;
+        server?: string | string[] | undefined;
     } | undefined;
 }>;

package/dist/mint-config/schemas/v2/properties/api.js

@@ -1,18 +1,18 @@
 import { z } from 'zod';
+import { openApiSchema } from './reusable/openapi.js';
 export const apiSchema = z
     .object({
+    openapi: openApiSchema.optional(),
     playground: z
         .object({
         display: z
             .enum(['interactive', 'simple', 'none'])
             .optional()
-            .default('interactive')
-            .describe('The display mode of the API playground'),
+            .describe('The display mode of the API playground. Defaults to `interactive`.'),
         proxy: z
             .boolean()
             .optional()
-            .default(false)
-            .describe('Whether to pass API requests through a proxy server'),
+            .describe('Whether to pass API requests through a proxy server. Defaults to `false`.'),
     })
         .optional()
         .describe('Configurations for the API playground'),
@@ -31,7 +31,7 @@ export const apiSchema = z
             .enum(['bearer', 'basic', 'key', 'cobo'])
             .optional()
             .describe('Authentication method for the API'),
-        base: z
+        server: z
             .union([z.string().url(), z.array(z.string().url())])
             .optional()
             .describe('Base URL(s) for the API'),

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare const appearanceSchema: z.ZodObject<{
-    default: z.ZodDefault<z.ZodEnum<["system", "light", "dark"]>>;
-    strict: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodEnum<["system", "light", "dark"]>>;
+    strict: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    strict: boolean;
-    default: "light" | "dark" | "system";
+    default?: "light" | "dark" | "system" | undefined;
+    strict?: boolean | undefined;
 }, {
     default?: "light" | "dark" | "system" | undefined;
     strict?: boolean | undefined;

package/dist/mint-config/schemas/v2/properties/appearance.js

@@ -3,8 +3,11 @@ export const appearanceSchema = z
     .object({
     default: z
         .enum(['system', 'light', 'dark'])
-        .default('system')
-        .describe('The default light/dark mode'),
-    strict: z.boolean().default(false).describe('Whether to hide the light / dark mode toggle'),
+        .optional()
+        .describe('The default light/dark mode. Defaults to system'),
+    strict: z
+        .boolean()
+        .optional()
+        .describe('Whether to hide the light / dark mode toggle. Defaults to `false`.'),
 })
     .describe('Light / dark mode toggle settings');

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

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const iconsSchema: z.ZodObject<{
-    library: z.ZodDefault<z.ZodEnum<["fontawesome"]>>;
+    library: z.ZodEnum<["fontawesome"]>;
 }, "strip", z.ZodTypeAny, {
     library: "fontawesome";
 }, {
-    library?: "fontawesome" | undefined;
+    library: "fontawesome";
 }>;

package/dist/mint-config/schemas/v2/properties/icons.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 export const iconsSchema = z
     .object({
-    library: z.enum(['fontawesome']).default('fontawesome').describe('The icon library to be used'),
+    library: z
+        .enum(['fontawesome'])
+        .describe('The icon library to be used. Defaults to `fontawesome`.'),
 })
     .describe('Icon library settings');

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

@@ -1 +1,10 @@
 export * from './font.js';
+export * from './navigation/index.js';
+export * from './navigation/anchors.js';
+export * from './navigation/global.js';
+export * from './navigation/groups.js';
+export * from './navigation/languages.js';
+export * from './navigation/pages.js';
+export * from './navigation/tabs.js';
+export * from './navigation/version.js';
+export * from './reusable/index.js';

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

@@ -1 +1,10 @@
 export * from './font.js';
+export * from './navigation/index.js';
+export * from './navigation/anchors.js';
+export * from './navigation/global.js';
+export * from './navigation/groups.js';
+export * from './navigation/languages.js';
+export * from './navigation/pages.js';
+export * from './navigation/tabs.js';
+export * from './navigation/version.js';
+export * from './reusable/index.js';

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

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-export declare const anchorSchema: z.ZodType;
 export declare const nonRecursiveAnchorSchema: z.ZodIntersection<z.ZodObject<{
     anchor: z.ZodString;
     icon: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodObject<{
@@ -23,6 +22,7 @@ export declare const nonRecursiveAnchorSchema: z.ZodIntersection<z.ZodObject<{
         dark?: string | undefined;
     }>>;
     hidden: z.ZodOptional<z.ZodBoolean>;
+    openapi: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">]>>;
 }, "strip", z.ZodTypeAny, {
     anchor: string;
     icon?: string | {
@@ -34,6 +34,7 @@ export declare const nonRecursiveAnchorSchema: z.ZodIntersection<z.ZodObject<{
         dark?: string | undefined;
     } | undefined;
     hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
 }, {
     anchor: string;
     icon?: string | {
@@ -45,6 +46,7 @@ export declare const nonRecursiveAnchorSchema: z.ZodIntersection<z.ZodObject<{
         dark?: string | undefined;
     } | undefined;
     hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
 }>, z.ZodObject<{
     href: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -52,6 +54,227 @@ export declare const nonRecursiveAnchorSchema: z.ZodIntersection<z.ZodObject<{
 }, {
     href: string;
 }>>;
-export declare const anchorsSchema: z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">;
+export declare const anchorSchema: z.ZodIntersection<z.ZodObject<{
+    anchor: z.ZodString;
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }>]>>;
+    color: z.ZodOptional<z.ZodObject<{
+        light: z.ZodOptional<z.ZodString>;
+        dark: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }>>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    openapi: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}>, z.ZodUnion<[z.ZodObject<{
+    href: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    href: string;
+}, {
+    href: string;
+}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, ...z.ZodType<any, z.ZodTypeDef, any>[]]>>;
+export declare const decoratedAnchorSchema: z.ZodIntersection<z.ZodObject<{
+    anchor: z.ZodString;
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }>]>>;
+    color: z.ZodOptional<z.ZodObject<{
+        light: z.ZodOptional<z.ZodString>;
+        dark: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }>>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    openapi: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}>, z.ZodUnion<[z.ZodObject<{
+    href: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    href: string;
+}, {
+    href: string;
+}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, ...z.ZodType<any, z.ZodTypeDef, any>[]]>>;
+export declare const anchorsSchema: z.ZodArray<z.ZodIntersection<z.ZodObject<{
+    anchor: z.ZodString;
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }>]>>;
+    color: z.ZodOptional<z.ZodObject<{
+        light: z.ZodOptional<z.ZodString>;
+        dark: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }>>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    openapi: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}>, z.ZodUnion<[z.ZodObject<{
+    href: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    href: string;
+}, {
+    href: string;
+}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, ...z.ZodType<any, z.ZodTypeDef, any>[]]>>, "many">;
+export declare const decoratedAnchorsSchema: z.ZodArray<z.ZodIntersection<z.ZodObject<{
+    anchor: z.ZodString;
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }, {
+        name: string;
+        style?: "brands" | "duotone" | "light" | "regular" | "sharp-duotone-solid" | "sharp-light" | "sharp-regular" | "sharp-solid" | "sharp-thin" | "solid" | "thin" | undefined;
+    }>]>>;
+    color: z.ZodOptional<z.ZodObject<{
+        light: z.ZodOptional<z.ZodString>;
+        dark: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }, {
+        light?: string | undefined;
+        dark?: string | undefined;
+    }>>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    openapi: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">]>>;
+}, "strip", z.ZodTypeAny, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}, {
+    anchor: 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;
+    color?: {
+        light?: string | undefined;
+        dark?: string | undefined;
+    } | undefined;
+    hidden?: boolean | undefined;
+    openapi?: string | string[] | undefined;
+}>, z.ZodUnion<[z.ZodObject<{
+    href: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    href: string;
+}, {
+    href: string;
+}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, ...z.ZodType<any, z.ZodTypeDef, any>[]]>>, "many">;
 export type AnchorsConfig = z.infer<typeof anchorsSchema>;
 export type AnchorConfig = z.infer<typeof anchorSchema>;
+export type DecoratedAnchorsConfig = z.infer<typeof decoratedAnchorsSchema>;
+export type DecoratedAnchorConfig = z.infer<typeof decoratedAnchorSchema>;

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

@@ -4,27 +4,21 @@ import { hiddenSchema } from '../reusable/hidden.js';
 import { hrefSchema } from '../reusable/href.js';
 import { iconSchema } from '../reusable/icon.js';
 import { openApiSchema } from '../reusable/openapi.js';
-import { dropdownsSchema } from './dropdown.js';
-import { groupsSchema } from './groups.js';
-import { languagesSchema } from './languages.js';
-import { pagesSchema } from './pages.js';
-import { tabsSchema } from './tabs.js';
-import { versionsSchema } from './version.js';
+import { getDivisionSchemasExcluding, registerDivisionSchema } from './divisionSchemas.js';
 const baseAnchorSchema = z.object({
     anchor: z.string().nonempty().describe('The name of the anchor'),
     icon: iconSchema.optional(),
     color: colorSchemaWithOptionalLightAndDark.optional(),
     hidden: hiddenSchema.optional(),
+    openapi: openApiSchema.optional(),
 });
-export const anchorSchema = baseAnchorSchema.and(z.union([
-    z.object({ openapi: openApiSchema }),
-    z.object({ href: hrefSchema }),
-    z.lazy(() => z.object({ languages: languagesSchema })),
-    z.lazy(() => z.object({ versions: versionsSchema })),
-    z.lazy(() => z.object({ dropdowns: dropdownsSchema })),
-    z.lazy(() => z.object({ tabs: tabsSchema })),
-    z.lazy(() => z.object({ groups: groupsSchema })),
-    z.lazy(() => z.object({ pages: pagesSchema })),
-]));
+const createAnchorSchema = (type) => baseAnchorSchema.and(z.union([z.object({ href: hrefSchema }), ...getDivisionSchemasExcluding('anchors', type)]));
 export const nonRecursiveAnchorSchema = baseAnchorSchema.and(z.object({ href: hrefSchema }));
+export const anchorSchema = createAnchorSchema('default');
+export const decoratedAnchorSchema = createAnchorSchema('decorated');
 export const anchorsSchema = z.array(anchorSchema).describe('Organizing by anchors');
+export const decoratedAnchorsSchema = z
+    .array(decoratedAnchorSchema)
+    .describe('Organizing by anchors');
+registerDivisionSchema('anchors', anchorsSchema, 'default');
+registerDivisionSchema('anchors', decoratedAnchorsSchema, 'decorated');

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

@@ -0,0 +1,7 @@
+import z from 'zod';
+import { Division } from '../reusable/divisions.js';
+import { NavigationSchemaType } from './index.js';
+export declare const divisionSchemas: Partial<Record<Division, z.ZodType>>;
+export declare const decoratedDivisionSchemas: Partial<Record<Division, z.ZodType>>;
+export declare function registerDivisionSchema(division: Division, schema: z.ZodType, type: NavigationSchemaType): void;
+export declare function getDivisionSchemasExcluding(division: Division, type: NavigationSchemaType): [z.ZodType, z.ZodType, ...z.ZodType[]];

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

@@ -0,0 +1,26 @@
+import z from 'zod';
+import { groupsSchema } from './groups.js';
+import { decoratedGroupsSchema } from './groups.js';
+import { decoratedPagesSchema, pagesSchema } from './pages.js';
+export const divisionSchemas = {};
+export const decoratedDivisionSchemas = {};
+export function registerDivisionSchema(division, schema, type) {
+    if (type === 'decorated') {
+        decoratedDivisionSchemas[division] = schema;
+    }
+    else {
+        divisionSchemas[division] = schema;
+    }
+}
+export function getDivisionSchemasExcluding(division, type) {
+    const schemas = type === 'decorated'
+        ? Object.entries(decoratedDivisionSchemas)
+            .filter(([key]) => key !== division)
+            .map(([key, schema]) => z.lazy(() => z.object({ [key]: schema })))
+            .concat(z.lazy(() => z.object({ groups: decoratedGroupsSchema })), z.lazy(() => z.object({ pages: decoratedPagesSchema })))
+        : Object.entries(divisionSchemas)
+            .filter(([key]) => key !== division)
+            .map(([key, schema]) => z.lazy(() => z.object({ [key]: schema })))
+            .concat(z.lazy(() => z.object({ groups: groupsSchema })), z.lazy(() => z.object({ pages: pagesSchema })));
+    return schemas;
+}