docs-cache 0.4.3 → 0.5.1

package/dist/esm/commands/verify.d.ts

@@ -0,0 +1,11 @@
+type VerifyOptions = {
+    configPath?: string;
+    cacheDirOverride?: string;
+    json: boolean;
+};
+export declare const verifyCache: (options: VerifyOptions) => Promise<{
+    cacheDir: any;
+    results: any;
+}>;
+export declare const printVerify: (report: Awaited<ReturnType<typeof verifyCache>>) => void;
+export {};

package/dist/esm/commands/verify.mjs

@@ -0,0 +1,120 @@
+import { access, stat } from "node:fs/promises";
+import path from "node:path";
+import { streamManifestEntries } from "#cache/manifest";
+import { symbols, ui } from "#cli/ui";
+import { DEFAULT_CACHE_DIR, loadConfig } from "#config";
+import { getErrnoCode } from "#core/errors";
+import { resolveCacheDir, resolveTargetDir } from "#core/paths";
+const exists = async (target) => {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export const verifyCache = async (options) => {
+  const { config, resolvedPath, sources } = await loadConfig(
+    options.configPath
+  );
+  const cacheDir = resolveCacheDir(
+    resolvedPath,
+    config.cacheDir ?? DEFAULT_CACHE_DIR,
+    options.cacheDirOverride
+  );
+  const verifyDir = async (directory, label) => {
+    if (!await exists(directory)) {
+      return {
+        ok: false,
+        issues: [
+          label === "source" ? "missing source directory" : "missing target directory"
+        ]
+      };
+    }
+    try {
+      let missingCount = 0;
+      let sizeMismatchCount = 0;
+      for await (const entry of streamManifestEntries(directory)) {
+        const filePath = path.join(directory, entry.path);
+        try {
+          const info = await stat(filePath);
+          if (info.size !== entry.size) {
+            sizeMismatchCount += 1;
+          }
+        } catch (error) {
+          const code = getErrnoCode(error);
+          if (code === "ENOENT" || code === "ENOTDIR") {
+            missingCount += 1;
+            continue;
+          }
+          throw error;
+        }
+      }
+      const issues = [];
+      if (missingCount > 0) {
+        issues.push(
+          label === "source" ? `missing files: ${missingCount}` : `target missing files: ${missingCount}`
+        );
+      }
+      if (sizeMismatchCount > 0) {
+        issues.push(
+          label === "source" ? `size mismatch: ${sizeMismatchCount}` : `target size mismatch: ${sizeMismatchCount}`
+        );
+      }
+      return {
+        ok: issues.length === 0,
+        issues
+      };
+    } catch (error) {
+      const code = getErrnoCode(error);
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        return {
+          ok: false,
+          issues: [
+            label === "source" ? "missing manifest" : "missing target manifest"
+          ]
+        };
+      }
+      throw error;
+    }
+  };
+  const results = await Promise.all(
+    sources.map(async (source) => {
+      const sourceDir = path.join(cacheDir, source.id);
+      const sourceReport = await verifyDir(sourceDir, "source");
+      const issues = [...sourceReport.issues];
+      if (source.targetDir && source.targetMode === "copy") {
+        const targetDir = resolveTargetDir(resolvedPath, source.targetDir);
+        const targetReport = await verifyDir(targetDir, "target");
+        issues.push(...targetReport.issues);
+      }
+      return {
+        id: source.id,
+        ok: issues.length === 0,
+        issues
+      };
+    })
+  );
+  return {
+    cacheDir,
+    results
+  };
+};
+export const printVerify = (report) => {
+  const okCount = report.results.filter((r) => r.ok).length;
+  const failCount = report.results.length - okCount;
+  if (report.results.length === 0) {
+    ui.line(`${symbols.warn} No sources to verify.`);
+    return;
+  }
+  ui.line(
+    `${symbols.info} Verified ${report.results.length} sources (${okCount} ok, ${failCount} failed)`
+  );
+  for (const result of report.results) {
+    if (result.ok) {
+      ui.item(symbols.success, result.id);
+    } else {
+      ui.item(symbols.warn, result.id, result.issues.join(", "));
+    }
+  }
+};

package/dist/esm/config/index.d.ts

@@ -0,0 +1,15 @@
+import type { CacheMode, DocsCacheConfig, DocsCacheDefaults, DocsCacheIntegrity, DocsCacheResolvedSource, DocsCacheSource, TocFormat } from "#config/schema";
+export type { CacheMode, DocsCacheConfig, DocsCacheDefaults, DocsCacheIntegrity, DocsCacheResolvedSource, DocsCacheSource, TocFormat, };
+export declare const DEFAULT_CONFIG_FILENAME = "docs.config.json";
+export declare const DEFAULT_CACHE_DIR = ".docs";
+export declare const DEFAULT_CONFIG: DocsCacheConfig;
+export declare const stripDefaultConfigValues: (config: DocsCacheConfig) => DocsCacheConfig;
+export declare const validateConfig: (input: unknown) => DocsCacheConfig;
+export declare const resolveSources: (config: DocsCacheConfig) => DocsCacheResolvedSource[];
+export declare const resolveConfigPath: (configPath?: string) => any;
+export declare const writeConfig: (configPath: string, config: DocsCacheConfig) => Promise<void>;
+export declare const loadConfig: (configPath?: string) => Promise<{
+    config: DocsCacheConfig;
+    resolvedPath: string;
+    sources: DocsCacheResolvedSource[];
+}>;

package/dist/esm/config/index.mjs

@@ -0,0 +1,196 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { ConfigSchema } from "#config/schema";
+import { resolveTargetDir } from "#core/paths";
+export const DEFAULT_CONFIG_FILENAME = "docs.config.json";
+export const DEFAULT_CACHE_DIR = ".docs";
+const PACKAGE_JSON_FILENAME = "package.json";
+const DEFAULT_TARGET_MODE = process.platform === "win32" ? "copy" : "symlink";
+export const DEFAULT_CONFIG = {
+  cacheDir: DEFAULT_CACHE_DIR,
+  defaults: {
+    ref: "HEAD",
+    mode: "materialize",
+    include: ["**/*.{md,mdx,markdown,mkd,txt,rst,adoc,asciidoc}"],
+    exclude: [],
+    targetMode: DEFAULT_TARGET_MODE,
+    required: true,
+    maxBytes: 2e8,
+    ignoreHidden: false,
+    allowHosts: ["github.com", "gitlab.com", "visualstudio.com"],
+    toc: true,
+    unwrapSingleRootDir: false
+  },
+  sources: []
+};
+const isEqualStringArray = (left, right) => {
+  if (!left || !right) {
+    return left === right;
+  }
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const pruneDefaults = (value, baseline) => {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const base = baseline[key];
+    if (Array.isArray(entry) && Array.isArray(base)) {
+      if (!isEqualStringArray(entry, base)) {
+        result[key] = entry;
+      }
+      continue;
+    }
+    if (isObject(entry) && isObject(base)) {
+      const pruned = pruneDefaults(entry, base);
+      if (Object.keys(pruned).length > 0) {
+        result[key] = pruned;
+      }
+      continue;
+    }
+    if (entry !== base) {
+      result[key] = entry;
+    }
+  }
+  return result;
+};
+export const stripDefaultConfigValues = (config) => {
+  const baseline = {
+    ...DEFAULT_CONFIG,
+    $schema: config.$schema,
+    defaults: {
+      ...DEFAULT_CONFIG.defaults,
+      ...config.targetMode ? { targetMode: config.targetMode } : void 0
+    }
+  };
+  const pruned = pruneDefaults(
+    config,
+    baseline
+  );
+  const next = {
+    $schema: pruned.$schema,
+    cacheDir: pruned.cacheDir,
+    targetMode: pruned.targetMode,
+    defaults: pruned.defaults,
+    sources: config.sources
+  };
+  if (!next.defaults || Object.keys(next.defaults).length === 0) {
+    delete next.defaults;
+  }
+  return next;
+};
+export const validateConfig = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new Error("Config must be a JSON object.");
+  }
+  const parsed = ConfigSchema.safeParse(input);
+  if (!parsed.success) {
+    const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"} ${issue.message}`).join("; ");
+    throw new Error(`Config does not match schema: ${details}.`);
+  }
+  const configInput = parsed.data;
+  const cacheDir = configInput.cacheDir ?? DEFAULT_CACHE_DIR;
+  const defaultValues = DEFAULT_CONFIG.defaults;
+  const targetModeOverride = configInput.targetMode;
+  const defaultsInput = configInput.defaults;
+  const defaults = {
+    ...defaultValues,
+    ...defaultsInput ?? {},
+    targetMode: defaultsInput?.targetMode ?? targetModeOverride ?? defaultValues.targetMode
+  };
+  return {
+    cacheDir,
+    targetMode: targetModeOverride,
+    defaults,
+    sources: configInput.sources
+  };
+};
+export const resolveSources = (config) => {
+  const defaults = config.defaults ?? DEFAULT_CONFIG.defaults;
+  const { allowHosts: _allowHosts, ...defaultValues } = defaults;
+  return config.sources.map((source) => ({
+    ...defaultValues,
+    ...source,
+    targetMode: source.targetMode ?? defaultValues.targetMode,
+    include: source.include ?? defaultValues.include,
+    exclude: source.exclude ?? defaultValues.exclude,
+    maxFiles: source.maxFiles ?? defaultValues.maxFiles,
+    toc: source.toc ?? defaultValues.toc,
+    unwrapSingleRootDir: source.unwrapSingleRootDir ?? defaultValues.unwrapSingleRootDir
+  }));
+};
+export const resolveConfigPath = (configPath) => configPath ? path.resolve(configPath) : path.resolve(process.cwd(), DEFAULT_CONFIG_FILENAME);
+const resolvePackagePath = () => path.resolve(process.cwd(), PACKAGE_JSON_FILENAME);
+const exists = async (target) => {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const loadConfigFromFile = async (filePath, mode) => {
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read config at ${filePath}: ${message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON in ${filePath}: ${message}`);
+  }
+  const configInput = mode === "package" ? parsed?.["docs-cache"] : parsed;
+  if (mode === "package" && configInput === void 0) {
+    throw new Error(`Missing docs-cache config in ${filePath}.`);
+  }
+  const config = validateConfig(configInput);
+  for (const source of config.sources) {
+    if (source.targetDir) {
+      resolveTargetDir(filePath, source.targetDir);
+    }
+  }
+  return {
+    config,
+    resolvedPath: filePath,
+    sources: resolveSources(config)
+  };
+};
+export const writeConfig = async (configPath, config) => {
+  const data = `${JSON.stringify(config, null, 2)}
+`;
+  await writeFile(configPath, data, "utf8");
+};
+export const loadConfig = async (configPath) => {
+  const resolvedPath = resolveConfigPath(configPath);
+  const isPackageConfig = path.basename(resolvedPath) === PACKAGE_JSON_FILENAME;
+  if (configPath) {
+    return loadConfigFromFile(
+      resolvedPath,
+      isPackageConfig ? "package" : "config"
+    );
+  }
+  if (await exists(resolvedPath)) {
+    return loadConfigFromFile(resolvedPath, "config");
+  }
+  const packagePath = resolvePackagePath();
+  if (await exists(packagePath)) {
+    try {
+      return await loadConfigFromFile(packagePath, "package");
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Missing docs-cache config")) {
+      } else {
+        throw error;
+      }
+    }
+  }
+  throw new Error(
+    `No docs.config.json found at ${resolvedPath} and no docs-cache config in ${packagePath}.`
+  );
+};

package/dist/esm/config/io.d.ts

@@ -0,0 +1,30 @@
+import { type DocsCacheConfig } from "#config";
+export type ConfigTarget = {
+    resolvedPath: string;
+    mode: "package" | "config";
+};
+export declare const loadPackageConfig: (configPath: string) => Promise<{
+    parsed: Record<string, unknown>;
+    config: any;
+}>;
+export declare const resolveConfigTarget: (configPath?: string) => Promise<ConfigTarget>;
+export declare const readConfigAtPath: (target: ConfigTarget, options?: {
+    allowMissing?: boolean;
+}) => Promise<{
+    config: any;
+    rawConfig: any;
+    rawPackage: Record<string, unknown>;
+    hadDocsCacheConfig: boolean;
+} | {
+    config: any;
+    rawConfig: any;
+    rawPackage: null;
+    hadDocsCacheConfig: boolean;
+}>;
+export declare const mergeConfigBase: (config: DocsCacheConfig, sources: DocsCacheConfig["sources"]) => DocsCacheConfig;
+export declare const writeConfigFile: (params: {
+    mode: "package" | "config";
+    resolvedPath: string;
+    config: DocsCacheConfig;
+    rawPackage: Record<string, unknown> | null;
+}) => Promise<void>;

package/dist/esm/config/io.mjs

@@ -0,0 +1,112 @@
+import { access, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import {
+  DEFAULT_CONFIG,
+  resolveConfigPath,
+  stripDefaultConfigValues,
+  validateConfig,
+  writeConfig
+} from "#config";
+const PACKAGE_JSON = "package.json";
+const SCHEMA_URL = "https://raw.githubusercontent.com/fbosch/docs-cache/main/docs.config.schema.json";
+const exists = async (target) => {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export const loadPackageConfig = async (configPath) => {
+  const raw = await readFile(configPath, "utf8");
+  const parsed = JSON.parse(raw);
+  const config = parsed["docs-cache"];
+  if (!config) {
+    return { parsed, config: null };
+  }
+  return {
+    parsed,
+    config: validateConfig(config)
+  };
+};
+export const resolveConfigTarget = async (configPath) => {
+  if (configPath) {
+    const resolvedPath = resolveConfigPath(configPath);
+    return {
+      resolvedPath,
+      mode: path.basename(resolvedPath) === PACKAGE_JSON ? "package" : "config"
+    };
+  }
+  const defaultPath = resolveConfigPath();
+  if (await exists(defaultPath)) {
+    return { resolvedPath: defaultPath, mode: "config" };
+  }
+  const packagePath = path.resolve(process.cwd(), PACKAGE_JSON);
+  if (await exists(packagePath)) {
+    const pkg = await loadPackageConfig(packagePath);
+    if (pkg.config) {
+      return { resolvedPath: packagePath, mode: "package" };
+    }
+  }
+  return { resolvedPath: defaultPath, mode: "config" };
+};
+export const readConfigAtPath = async (target, options) => {
+  if (!await exists(target.resolvedPath)) {
+    if (!options?.allowMissing) {
+      throw new Error(`Config not found at ${target.resolvedPath}.`);
+    }
+    if (target.mode === "package") {
+      throw new Error(`package.json not found at ${target.resolvedPath}.`);
+    }
+    return {
+      config: DEFAULT_CONFIG,
+      rawConfig: null,
+      rawPackage: null,
+      hadDocsCacheConfig: false
+    };
+  }
+  if (target.mode === "package") {
+    const pkg = await loadPackageConfig(target.resolvedPath);
+    return {
+      config: pkg.config ?? DEFAULT_CONFIG,
+      rawConfig: pkg.config,
+      rawPackage: pkg.parsed,
+      hadDocsCacheConfig: Boolean(pkg.config)
+    };
+  }
+  const raw = await readFile(target.resolvedPath, "utf8");
+  const rawConfig = JSON.parse(raw.toString());
+  return {
+    config: validateConfig(rawConfig),
+    rawConfig,
+    rawPackage: null,
+    hadDocsCacheConfig: true
+  };
+};
+export const mergeConfigBase = (config, sources) => {
+  const nextConfig = {
+    $schema: config.$schema ?? SCHEMA_URL,
+    sources
+  };
+  if (config.cacheDir) {
+    nextConfig.cacheDir = config.cacheDir;
+  }
+  if (config.defaults) {
+    nextConfig.defaults = config.defaults;
+  }
+  if (config.targetMode) {
+    nextConfig.targetMode = config.targetMode;
+  }
+  return nextConfig;
+};
+export const writeConfigFile = async (params) => {
+  const { mode, resolvedPath, config, rawPackage } = params;
+  if (mode === "package") {
+    const pkg = rawPackage ?? {};
+    pkg["docs-cache"] = stripDefaultConfigValues(config);
+    await writeFile(resolvedPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+    return;
+  }
+  await writeConfig(resolvedPath, config);
+};

package/dist/esm/config/schema.d.ts

@@ -0,0 +1,171 @@
+import * as z from "zod";
+export declare const TargetModeSchema: z.ZodEnum<{
+    symlink: "symlink";
+    copy: "copy";
+}>;
+export declare const CacheModeSchema: z.ZodEnum<{
+    materialize: "materialize";
+}>;
+export declare const TocFormatSchema: z.ZodEnum<{
+    compressed: "compressed";
+    tree: "tree";
+}>;
+export declare const IntegritySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        commit: "commit";
+        manifest: "manifest";
+    }>;
+    value: z.ZodNullable<z.ZodString>;
+}, z.z.core.$strict>;
+export declare const DefaultsSchema: z.ZodObject<{
+    ref: z.ZodString;
+    mode: z.ZodEnum<{
+        materialize: "materialize";
+    }>;
+    include: z.ZodArray<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    targetMode: z.ZodOptional<z.ZodEnum<{
+        symlink: "symlink";
+        copy: "copy";
+    }>>;
+    required: z.ZodBoolean;
+    maxBytes: z.ZodNumber;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    ignoreHidden: z.ZodBoolean;
+    toc: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        compressed: "compressed";
+        tree: "tree";
+    }>]>>;
+    unwrapSingleRootDir: z.ZodOptional<z.ZodBoolean>;
+    allowHosts: z.ZodArray<z.ZodString>;
+}, z.z.core.$strict>;
+export declare const SourceSchema: z.ZodObject<{
+    ref: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        materialize: "materialize";
+    }>>;
+    exclude: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    targetMode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        symlink: "symlink";
+        copy: "copy";
+    }>>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    maxBytes: z.ZodOptional<z.ZodNumber>;
+    maxFiles: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    ignoreHidden: z.ZodOptional<z.ZodBoolean>;
+    toc: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        compressed: "compressed";
+        tree: "tree";
+    }>]>>>;
+    unwrapSingleRootDir: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    id: z.ZodString;
+    repo: z.ZodString;
+    targetDir: z.ZodOptional<z.ZodString>;
+    integrity: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            commit: "commit";
+            manifest: "manifest";
+        }>;
+        value: z.ZodNullable<z.ZodString>;
+    }, z.z.core.$strict>>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.z.core.$strict>;
+export declare const ResolvedSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    repo: z.ZodString;
+    targetDir: z.ZodOptional<z.ZodString>;
+    integrity: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            commit: "commit";
+            manifest: "manifest";
+        }>;
+        value: z.ZodNullable<z.ZodString>;
+    }, z.z.core.$strict>>;
+    ref: z.ZodString;
+    mode: z.ZodEnum<{
+        materialize: "materialize";
+    }>;
+    include: z.ZodArray<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    targetMode: z.ZodOptional<z.ZodEnum<{
+        symlink: "symlink";
+        copy: "copy";
+    }>>;
+    required: z.ZodBoolean;
+    maxBytes: z.ZodNumber;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    ignoreHidden: z.ZodBoolean;
+    toc: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        compressed: "compressed";
+        tree: "tree";
+    }>]>>;
+    unwrapSingleRootDir: z.ZodOptional<z.ZodBoolean>;
+}, z.z.core.$strict>;
+export declare const ConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    cacheDir: z.ZodOptional<z.ZodString>;
+    targetMode: z.ZodOptional<z.ZodEnum<{
+        symlink: "symlink";
+        copy: "copy";
+    }>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            materialize: "materialize";
+        }>>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        targetMode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            symlink: "symlink";
+            copy: "copy";
+        }>>>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        maxFiles: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        ignoreHidden: z.ZodOptional<z.ZodBoolean>;
+        toc: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+            compressed: "compressed";
+            tree: "tree";
+        }>]>>>;
+        unwrapSingleRootDir: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        allowHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            materialize: "materialize";
+        }>>;
+        exclude: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        targetMode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            symlink: "symlink";
+            copy: "copy";
+        }>>>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        maxFiles: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        ignoreHidden: z.ZodOptional<z.ZodBoolean>;
+        toc: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+            compressed: "compressed";
+            tree: "tree";
+        }>]>>>;
+        unwrapSingleRootDir: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        id: z.ZodString;
+        repo: z.ZodString;
+        targetDir: z.ZodOptional<z.ZodString>;
+        integrity: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                commit: "commit";
+                manifest: "manifest";
+            }>;
+            value: z.ZodNullable<z.ZodString>;
+        }, z.z.core.$strict>>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.z.core.$strict>>;
+}, z.z.core.$strict>;
+export type DocsCacheDefaults = z.infer<typeof DefaultsSchema>;
+export type DocsCacheSource = z.infer<typeof SourceSchema>;
+export type DocsCacheResolvedSource = z.infer<typeof ResolvedSourceSchema>;
+export type DocsCacheConfig = z.infer<typeof ConfigSchema>;
+export type DocsCacheIntegrity = z.infer<typeof IntegritySchema>;
+export type CacheMode = z.infer<typeof CacheModeSchema>;
+export type TocFormat = z.infer<typeof TocFormatSchema>;