@gradial/aci 0.1.52-rc.9 → 0.1.52

package/dist/mintlify/config.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { canonicalize, isExternalReference, isObject } from './json.js';
+export function toDocsJSON(site) {
+    const { $schema: _schema, ...configuration } = site;
+    return canonicalize({
+        $schema: 'https://mintlify.com/docs.json',
+        ...(typeof configuration.theme === 'string' ? {} : { theme: 'mint' }),
+        ...configuration,
+    });
+}
+export function resolveConfigReferences(configuration, fragments) {
+    const byPath = new Map();
+    for (const fragment of fragments) {
+        if (byPath.has(fragment.path))
+            throw new Error(`ACI Mintlify config fragment path is duplicated: ${fragment.path}`);
+        byPath.set(fragment.path, fragment.value);
+    }
+    return resolveConfigValue(configuration, 'docs.json', byPath, new Set());
+}
+function resolveConfigValue(value, currentPath, fragments, stack) {
+    if (Array.isArray(value))
+        return value.map((entry) => resolveConfigValue(entry, currentPath, fragments, stack));
+    if (!isObject(value))
+        return value;
+    if (typeof value.$ref === 'string' && !isExternalReference(value.$ref)) {
+        const reference = resolveConfigReferencePath(currentPath, value.$ref);
+        const target = fragments.get(reference.path);
+        if (target === undefined)
+            throw new Error(`ACI Mintlify config reference is missing: ${value.$ref} from ${currentPath}`);
+        const cycleKey = `${reference.path}#${reference.pointer.join('/')}`;
+        if (stack.has(cycleKey))
+            throw new Error(`ACI Mintlify config reference cycle includes: ${cycleKey}`);
+        const nextStack = new Set(stack).add(cycleKey);
+        const selected = resolveJSONPointer(target, reference.pointer, value.$ref);
+        const resolvedTarget = resolveConfigValue(selected, reference.path, fragments, nextStack);
+        const siblings = Object.fromEntries(Object.entries(value)
+            .filter(([key]) => key !== '$ref')
+            .map(([key, child]) => [key, resolveConfigValue(child, currentPath, fragments, stack)]));
+        if (Object.keys(siblings).length === 0)
+            return resolvedTarget;
+        if (!isObject(resolvedTarget))
+            throw new Error(`ACI Mintlify config reference with sibling keys must resolve to an object: ${value.$ref}`);
+        return { ...resolvedTarget, ...siblings };
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, resolveConfigValue(child, currentPath, fragments, stack)]));
+}
+function resolveConfigReferencePath(currentPath, reference) {
+    const [rawPath, rawPointer = ''] = reference.split('#', 2);
+    if (!rawPath)
+        throw new Error(`ACI Mintlify local config reference requires a file path: ${reference}`);
+    const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(currentPath), rawPath));
+    if (resolved.startsWith('../') || resolved.startsWith('/') || !resolved.endsWith('.json')) {
+        throw new Error(`ACI Mintlify config reference path is invalid: ${reference}`);
+    }
+    const pointer = rawPointer === '' ? [] : rawPointer.startsWith('/')
+        ? rawPointer.slice(1).split('/').map((part) => part.replaceAll('~1', '/').replaceAll('~0', '~'))
+        : (() => { throw new Error(`ACI Mintlify config reference pointer is invalid: ${reference}`); })();
+    return { path: resolved, pointer };
+}
+function resolveJSONPointer(value, pointer, reference) {
+    let current = value;
+    for (const part of pointer) {
+        if (Array.isArray(current)) {
+            const index = Number(part);
+            if (!Number.isInteger(index) || index < 0 || index >= current.length)
+                throw new Error(`ACI Mintlify config reference pointer is missing: ${reference}`);
+            current = current[index];
+        }
+        else if (isObject(current) && Object.hasOwn(current, part)) {
+            current = current[part];
+        }
+        else {
+            throw new Error(`ACI Mintlify config reference pointer is missing: ${reference}`);
+        }
+    }
+    return current;
+}

package/dist/mintlify/index.d.ts

@@ -0,0 +1,3 @@
+export { materializeMintlifySite, resolveMintlifyDocument, loadMintlifySource, loadCompiledMintlifySource, } from './materialize.js';
+export { renderDocument, renderSnippet } from './blocks.js';
+export type { MintlifyAPISpec, MintlifyBlock, MintlifyConfigFragment, MintlifyDocument, MintlifyJSONValue, MintlifyNavigationGroup, MintlifySite, MintlifySnippet, MintlifySource, } from './types.js';

package/dist/mintlify/index.js

@@ -0,0 +1,2 @@
+export { materializeMintlifySite, resolveMintlifyDocument, loadMintlifySource, loadCompiledMintlifySource, } from './materialize.js';
+export { renderDocument, renderSnippet } from './blocks.js';

package/dist/mintlify/json.d.ts

@@ -0,0 +1,8 @@
+import type { MintlifyJSONValue } from './types.js';
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function nonEmptyString(value: unknown): value is string;
+export declare function isMintlifyJSONValue(value: unknown): value is MintlifyJSONValue;
+export declare function canonicalize(value: MintlifyJSONValue): MintlifyJSONValue;
+export declare function isExternalReference(value: string): boolean;
+export declare function cleanDocumentPath(value: string): string;
+export declare function cleanFilePath(value: string, extension: string): string;

package/dist/mintlify/json.js

@@ -0,0 +1,37 @@
+export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function isMintlifyJSONValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isMintlifyJSONValue);
+    return isObject(value) && Object.values(value).every(isMintlifyJSONValue);
+}
+export function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (!isObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, canonicalize(child)]));
+}
+export function isExternalReference(value) {
+    return /^(?:https?:)?\/\//i.test(value) || value.startsWith('mailto:');
+}
+export function cleanDocumentPath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+    if (!normalized || normalized.endsWith('.md') || normalized.endsWith('.mdx') || normalized.split('/').some((part) => !part || part === '.' || part === '..'))
+        return '';
+    return normalized;
+}
+export function cleanFilePath(value, extension) {
+    const normalized = value.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+    if (!normalized.endsWith(extension) || normalized.split('/').some((part) => !part || part === '.' || part === '..'))
+        return '';
+    return normalized;
+}

package/dist/mintlify/materialize.d.ts

@@ -0,0 +1,14 @@
+import type { MaterializeMintlifySiteOptions, MintlifyDocument, MintlifySource } from './types.js';
+/**
+ * Reads a site and its documents from ACI's portable JSON content tree.
+ * The source shape is standard ACI content: `config/mintlify.json`, resources
+ * below `pages/` and `fragments/`; the generated Mintlify tree is not
+ * source content and must live outside this directory.
+ */
+export declare function loadMintlifySource(sourceDir: string): Promise<MintlifySource>;
+/** Loads resolved pages/fragments from ACI compiler output for framework projection. */
+export declare function loadCompiledMintlifySource(sourceDir: string, compiledDir: string): Promise<MintlifySource>;
+/** Materializes one exact Mintlify site from ACI source content. */
+export declare function materializeMintlifySite(options: MaterializeMintlifySiteOptions): Promise<void>;
+/** Project a runtime page using only its selected, immutable fragment bindings. */
+export declare function resolveMintlifyDocument(value: unknown, fragments: Record<string, unknown>, documentPath: string, layout: unknown): Promise<MintlifyDocument>;

package/dist/mintlify/materialize.js

@@ -0,0 +1,254 @@
+import { resolveSlots, resolveFragmentNodes } from '../content/resolve-slots.js';
+import { FragmentNotFoundError } from '../content/provider.js';
+import { mkdir, readFile, readdir, writeFile, } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveConfigReferences, toDocsJSON } from './config.js';
+import { renderDocument, renderSnippet } from './blocks.js';
+import { canonicalize, isObject, } from './json.js';
+import { validateAPISpec, validateConfigFragment, validateDocument, validateSite, validateSnippet, validateSource, } from './validate.js';
+/**
+ * Reads a site and its documents from ACI's portable JSON content tree.
+ * The source shape is standard ACI content: `config/mintlify.json`, resources
+ * below `pages/` and `fragments/`; the generated Mintlify tree is not
+ * source content and must live outside this directory.
+ */
+export async function loadMintlifySource(sourceDir) {
+    const sitePath = path.join(sourceDir, 'config', 'mintlify.json');
+    const pagesDir = path.join(sourceDir, 'pages');
+    const [site, pageResources, fragmentResources, configFragments, apiSpecs] = await Promise.all([
+        readJSON(sitePath),
+        readIndexResources(pagesDir),
+        readOptionalIndexResources(path.join(sourceDir, 'fragments')),
+        readOptionalJSONResources(path.join(sourceDir, 'config', 'mintlify')),
+        readOptionalJSONResources(path.join(sourceDir, 'data', 'mintlify-api')),
+    ]);
+    const sourceFragments = new Map(fragmentResources.map(({ value, relative }) => [relative.slice(0, -'/_index.json'.length), value]));
+    const getFragment = async (id) => {
+        if (!sourceFragments.has(id))
+            throw new FragmentNotFoundError(id);
+        return sourceFragments.get(id);
+    };
+    return {
+        site: validateSite(site, sitePath),
+        documents: await Promise.all(pageResources.map(async ({ value, file, relative }) => validateDocument(await expandDocument(value, getFragment), file, relative === '_index.json' ? 'index' : relative.slice(0, -'/_index.json'.length)))),
+        snippets: await Promise.all(fragmentResources.map(async ({ value, file, relative }) => {
+            const id = relative.slice(0, -'/_index.json'.length);
+            return validateSnippet(await expandSnippet(value, id, getFragment), file, `${id}.mdx`);
+        })),
+        configFragments: configFragments.map(({ value, file }) => validateConfigFragment(value, file)),
+        apiSpecs: apiSpecs.map(({ value, file }) => validateAPISpec(value, file)),
+    };
+}
+/** Loads resolved pages/fragments from ACI compiler output for framework projection. */
+export async function loadCompiledMintlifySource(sourceDir, compiledDir) {
+    const sitePath = path.join(sourceDir, 'config', 'mintlify.json');
+    const manifestPath = path.join(compiledDir, 'manifest.json');
+    const [siteValue, manifestValue, configFragments, apiSpecs] = await Promise.all([
+        readJSON(sitePath), readJSON(manifestPath),
+        readOptionalJSONResources(path.join(sourceDir, 'config', 'mintlify')),
+        readOptionalJSONResources(path.join(sourceDir, 'data', 'mintlify-api')),
+    ]);
+    if (!isObject(manifestValue) || !isObject(manifestValue.routes) || !isObject(manifestValue.fragments)) {
+        throw new Error(`ACI compiled manifest is invalid: ${manifestPath}`);
+    }
+    const fragments = await Promise.all(Object.entries(manifestValue.fragments).map(async ([id, entry]) => {
+        if (!isObject(entry) || typeof entry.payloadRef !== 'string')
+            throw new Error(`ACI compiled fragment is invalid: ${id}`);
+        return { id, entry, value: await readJSON(safeOutputPath(compiledDir, entry.payloadRef)) };
+    }));
+    const byId = new Map(fragments.map(({ id, value }) => [id, value]));
+    const getFragment = async (id) => {
+        if (!byId.has(id))
+            throw new FragmentNotFoundError(id);
+        return byId.get(id);
+    };
+    const documents = await Promise.all(Object.entries(manifestValue.routes).map(async ([slug, entry]) => {
+        if (!isObject(entry) || typeof entry.payloadRef !== 'string')
+            throw new Error(`ACI compiled route is invalid: ${slug}`);
+        const value = await readJSON(safeOutputPath(compiledDir, entry.payloadRef));
+        const layout = isObject(value) && typeof value.layout === 'string' && isObject(manifestValue.layouts)
+            ? manifestValue.layouts[value.layout] : undefined;
+        const plan = requireMintlifyLayout(value, layout, entry.payloadRef);
+        return validateDocument(await expandDocument(value, getFragment, plan), entry.payloadRef, slug || 'index');
+    }));
+    const snippets = await Promise.all(fragments.map(async ({ id, entry, value }) => validateSnippet(await expandSnippet(value, id, getFragment), String(entry.payloadRef), `${id}.mdx`)));
+    return {
+        site: validateSite(siteValue, sitePath), documents, snippets,
+        configFragments: configFragments.map(({ value, file }) => validateConfigFragment(value, file)),
+        apiSpecs: apiSpecs.map(({ value, file }) => validateAPISpec(value, file)),
+    };
+}
+/** Materializes one exact Mintlify site from ACI source content. */
+export async function materializeMintlifySite(options) {
+    const outputDir = path.resolve(options.outputDir);
+    const site = validateSite(options.site, 'site');
+    const getFragment = fragmentLoader(options.snippets ?? []);
+    const documents = await Promise.all(options.documents.map(async (document, index) => validateDocument(await expandDocument(document, getFragment), `documents[${index}]`, document.path)));
+    const snippets = await Promise.all((options.snippets ?? []).map(async (snippet, index) => validateSnippet(await expandSnippet(snippet, snippet.id, getFragment), `snippets[${index}]`, snippet.path)));
+    const configFragments = (options.configFragments ?? []).map((fragment, index) => validateConfigFragment(fragment, `configFragments[${index}]`));
+    const apiSpecs = (options.apiSpecs ?? []).map((spec, index) => validateAPISpec(spec, `apiSpecs[${index}]`));
+    const nativeConfig = toDocsJSON(site);
+    const resolvedConfig = resolveConfigReferences(nativeConfig, configFragments);
+    validateSource(resolvedConfig, documents, snippets, apiSpecs);
+    const generated = new Map();
+    addGenerated(generated, 'docs.json', `${JSON.stringify(nativeConfig, null, 2)}\n`);
+    for (const fragment of configFragments) {
+        addGenerated(generated, fragment.path, `${JSON.stringify(canonicalize(fragment.value), null, 2)}\n`);
+    }
+    for (const snippet of snippets) {
+        addGenerated(generated, snippet.path, renderSnippet(snippet));
+    }
+    for (const spec of apiSpecs) {
+        addGenerated(generated, spec.path, spec.source.replace(/\r\n/g, '\n').replace(/\n*$/, '\n'));
+    }
+    for (const document of documents) {
+        addGenerated(generated, `${document.path}.mdx`, renderDocument(document));
+    }
+    await mkdir(outputDir, { recursive: true });
+    for (const [relativePath, contents] of generated) {
+        const destination = safeOutputPath(outputDir, relativePath);
+        await mkdir(path.dirname(destination), { recursive: true });
+        await writeFile(destination, contents, 'utf8');
+    }
+}
+function addGenerated(generated, outputPath, contents) {
+    if (generated.has(outputPath))
+        throw new Error(`ACI Mintlify generated output path is duplicated: ${outputPath}`);
+    generated.set(outputPath, contents);
+}
+async function readDocuments(directory) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        throw new Error(`ACI Mintlify documents directory is required: ${directory}`, { cause: error });
+    }
+    const results = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            results.push(...await readDocuments(file));
+        else if (entry.isFile() && entry.name.endsWith('.json'))
+            results.push({ file, value: await readJSON(file) });
+    }
+    return results;
+}
+async function readIndexResources(directory, root = directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            results.push(...await readIndexResources(file, root));
+        else if (entry.isFile() && entry.name === '_index.json')
+            results.push({ file, relative: path.relative(root, file).split(path.sep).join('/'), value: await readJSON(file) });
+    }
+    return results;
+}
+async function readOptionalIndexResources(directory) {
+    try {
+        return await readIndexResources(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function readOptionalJSONResources(directory) {
+    try {
+        return await readDocuments(directory);
+    }
+    catch (error) {
+        if (error.cause && error.cause.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+async function readJSON(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`ACI Mintlify source is not valid JSON: ${file}`, { cause: error });
+    }
+}
+function safeOutputPath(root, relativePath) {
+    const target = path.resolve(root, relativePath);
+    if (target === root || !target.startsWith(`${root}${path.sep}`))
+        throw new Error(`ACI Mintlify generated path escapes output directory: ${relativePath}`);
+    return target;
+}
+function fragmentLoader(fragments) {
+    const byId = new Map();
+    for (const fragment of fragments) {
+        if (!isObject(fragment) || typeof fragment.id !== 'string')
+            continue;
+        if (byId.has(fragment.id))
+            throw new Error(`ACI fragment ID is duplicated: ${fragment.id}`);
+        byId.set(fragment.id, fragment);
+    }
+    return async (id) => {
+        const fragment = byId.get(id);
+        if (!fragment)
+            throw new FragmentNotFoundError(id);
+        return fragment;
+    };
+}
+function requireMintlifyLayout(page, value, label) {
+    if (!isObject(page) || !isObject(value) || typeof value.name !== 'string'
+        || page.layout !== value.name || !Array.isArray(value.slots)) {
+        throw new Error(`ACI Mintlify document ${label} requires its exact bound template render plan`);
+    }
+    for (const slot of value.slots) {
+        if (!isObject(slot) || slot.name !== 'main') {
+            throw new Error(`ACI Mintlify template ${value.name} has unsupported region ${JSON.stringify(isObject(slot) ? slot.name : slot)}; only main is supported (${label})`);
+        }
+    }
+    if (value.slots.length !== 1)
+        throw new Error(`ACI Mintlify template ${value.name} must declare exactly one main region (${label})`);
+    if (value.defaults !== undefined) {
+        if (!isObject(value.defaults))
+            throw new Error(`ACI Mintlify template ${value.name} has invalid defaults (${label})`);
+        for (const [region, nodes] of Object.entries(value.defaults)) {
+            if (region !== 'main')
+                throw new Error(`ACI Mintlify template ${value.name} has unsupported default region ${JSON.stringify(region)}; only main is supported (${label})`);
+            if (!Array.isArray(nodes))
+                throw new Error(`ACI Mintlify template ${value.name} has invalid main defaults (${label})`);
+        }
+    }
+    return value;
+}
+async function expandDocument(value, getFragment, layout) {
+    if (!isObject(value) || !isObject(value.regions))
+        return value;
+    if (Object.hasOwn(value.regions, 'main') && !Array.isArray(value.regions.main))
+        return value;
+    if (layout) {
+        const resolved = await resolveSlots(layout, value.regions, getFragment);
+        // Preserve unexpected authored keys so validateDocument can refuse them.
+        return { ...value, regions: { ...value.regions, main: resolved.main ?? [] } };
+    }
+    if (!Array.isArray(value.regions.main))
+        return value;
+    return { ...value, regions: { ...value.regions, main: await resolveFragmentNodes(value.regions.main, getFragment) } };
+}
+/** Project a runtime page using only its selected, immutable fragment bindings. */
+export async function resolveMintlifyDocument(value, fragments, documentPath, layout) {
+    const getFragment = async (id) => {
+        if (!Object.hasOwn(fragments, id))
+            throw new FragmentNotFoundError(id);
+        return fragments[id];
+    };
+    const plan = requireMintlifyLayout(value, layout, documentPath);
+    return validateDocument(await expandDocument(value, getFragment, plan), documentPath, documentPath);
+}
+// Standalone snippets traverse the root reference too, so a root self-reference
+// uses the same ancestry/depth checks as a page placement.
+async function expandSnippet(value, id, getFragment) {
+    if (!isObject(value))
+        return value;
+    const [block] = await resolveFragmentNodes([{ kind: 'fragment-ref', fragmentId: id }], getFragment);
+    return { ...value, id: value.id ?? id, block };
+}

package/dist/mintlify/types.d.ts

@@ -0,0 +1,74 @@
+import type { FragmentRefNode } from '../types/page.js';
+export type MintlifyJSONValue = null | boolean | number | string | MintlifyJSONValue[] | {
+    [key: string]: MintlifyJSONValue;
+};
+export interface MintlifyNavigationGroup {
+    group: string;
+    pages: string[];
+}
+/** Native Mintlify docs.json configuration from `.content/config/mintlify.json`. */
+export type MintlifySite = Record<string, MintlifyJSONValue>;
+export interface MintlifyBlock {
+    $type: 'component';
+    id: string;
+    component: 'mintlify.markdown' | 'mintlify.mdx' | 'mintlify.anchor' | 'mintlify.steps' | 'mintlify.step' | 'mintlify.card-group' | 'mintlify.card' | 'mintlify.accordion-group' | 'mintlify.accordion' | 'mintlify.callout' | 'mintlify.tabs' | 'mintlify.tab' | 'mintlify.snippet-ref';
+    props: {
+        source?: string;
+        name?: string;
+        variant?: 'info' | 'warning' | 'note' | 'tip' | 'check';
+        children?: MintlifyBlock[];
+        [key: string]: MintlifyJSONValue | MintlifyBlock[] | undefined;
+    };
+}
+export interface MintlifyDocument {
+    $type: 'page';
+    id: string;
+    status: string;
+    path: string;
+    metadata: {
+        title: string;
+        description?: string;
+        mintlify?: {
+            sidebarTitle?: string;
+            icon?: string;
+            frontmatter?: Record<string, MintlifyJSONValue>;
+        };
+    };
+    regions: {
+        main: MintlifyBlock[];
+    };
+}
+export interface MintlifySnippet {
+    $type: 'fragment';
+    id: string;
+    path: string;
+    block: MintlifyBlock;
+}
+export interface MintlifyConfigFragment {
+    $type: 'mintlify.config-fragment';
+    schemaVersion: 1;
+    path: string;
+    value: MintlifyJSONValue;
+}
+export interface MintlifyAPISpec {
+    $type: 'mintlify.api-spec';
+    schemaVersion: 1;
+    path: string;
+    format: 'openapi' | 'asyncapi' | 'graphql';
+    source: string;
+}
+export interface MintlifySource {
+    site: MintlifySite;
+    documents: MintlifyDocument[];
+    snippets?: MintlifySnippet[];
+    configFragments?: MintlifyConfigFragment[];
+    apiSpecs?: MintlifyAPISpec[];
+}
+export interface MaterializeMintlifySiteOptions extends Omit<MintlifySource, 'documents'> {
+    documents: Array<Omit<MintlifyDocument, 'regions'> & {
+        regions: {
+            main: Array<MintlifyBlock | FragmentRefNode>;
+        };
+    }>;
+    outputDir: string;
+}

package/dist/mintlify/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mintlify/validate.d.ts

@@ -0,0 +1,7 @@
+import type { MintlifyAPISpec, MintlifyConfigFragment, MintlifyDocument, MintlifyJSONValue, MintlifySite, MintlifySnippet } from './types.js';
+export declare function validateSource(site: MintlifyJSONValue, documents: MintlifyDocument[], snippets: MintlifySnippet[], apiSpecs: MintlifyAPISpec[]): void;
+export declare function validateSite(value: unknown, label: string): MintlifySite;
+export declare function validateDocument(value: unknown, label: string, sourcePath?: string): MintlifyDocument;
+export declare function validateSnippet(value: unknown, label: string, sourcePath?: string): MintlifySnippet;
+export declare function validateConfigFragment(value: unknown, label: string): MintlifyConfigFragment;
+export declare function validateAPISpec(value: unknown, label: string): MintlifyAPISpec;