@lupinum/ginko-content 0.1.0

package/dist/core/content/path.js

@@ -0,0 +1,143 @@
+import { pascalCase } from "scule";
+import { withLeadingSlash, withoutTrailingSlash } from "ufo";
+import { slugifyUrlSegment } from "./slug.js";
+const SEMVER_REGEX = /^(\d+)(\.\d+)*(\.x)?$/;
+const NUMERIC_PREFIX_RE = /^(\d+)\.(.+)$/;
+export const describeId = (id) => {
+  const [_source, ...parts] = id.split(":");
+  const [, basename, _extension] = parts[parts.length - 1]?.match(/(.*)\.([^.]+)$/) || [];
+  if (basename) {
+    parts[parts.length - 1] = basename;
+  }
+  const _path = (parts || []).join("/");
+  return {
+    _source,
+    _path,
+    _extension,
+    _file: _extension ? `${_path}.${_extension}` : _path,
+    _basename: basename || ""
+  };
+};
+export const isDraftPath = (path) => /\.draft(\/|\.|$)/.test(path);
+export const isPartialPath = (path) => path.split(/[:/]/).some((part) => /^_.*/.test(part));
+export const normalizeContentPath = (path) => {
+  if (!path || path === "/") {
+    return "/";
+  }
+  return path.endsWith("/") ? path.slice(0, -1) || "/" : path;
+};
+export function refineUrlPart(name) {
+  name = name.split(/[/:]/).pop();
+  if (SEMVER_REGEX.test(name)) {
+    return name;
+  }
+  return name.replace(/(\d+\.)?(.*)/, "$2").replace(/^index(\.draft)?$/, "").replace(/\.draft$/, "");
+}
+export const generatePath = (path, { forceLeadingSlash = true, respectPathCase = false } = {}) => {
+  const generatedPath = path.split("/").map((part) => slugifyUrlSegment(refineUrlPart(part), { lower: !respectPathCase })).join("/");
+  return forceLeadingSlash ? withLeadingSlash(withoutTrailingSlash(generatedPath)) : generatedPath;
+};
+const parseSegment = (part) => {
+  const base = part.split(/[/:]/).pop() || "";
+  const refined = refineUrlPart(base);
+  const match = base.match(NUMERIC_PREFIX_RE);
+  return {
+    refined,
+    number: match?.[1]
+  };
+};
+export const generateCanonicalKey = (parts, { translatedSlugs = false, respectPathCase = false } = {}) => {
+  const segments = parts.map(parseSegment).filter((segment) => segment.refined.length > 0);
+  if (!translatedSlugs) {
+    return generatePath(segments.map((segment) => segment.refined).join("/"), { respectPathCase }) || "/";
+  }
+  const translatedSegments = segments.map((segment) => {
+    if (segment.number) {
+      return segment.number;
+    }
+    return slugifyUrlSegment(segment.refined, { lower: !respectPathCase }) || segment.refined;
+  });
+  return translatedSegments.length ? translatedSegments.join("/") : "/";
+};
+export const generateTitle = (path) => path.split(/[\s-]/g).map(pascalCase).join(" ");
+export const normalizeRouteMounts = (route, locales = [], defaultLocale) => {
+  if (!route) {
+    return void 0;
+  }
+  if (typeof route === "string") {
+    const localeList = locales.length ? locales : defaultLocale ? [defaultLocale] : [];
+    if (!localeList.length) {
+      return defaultLocale ? { [defaultLocale]: normalizeContentPath(route) } : void 0;
+    }
+    return Object.fromEntries(localeList.map((locale) => [locale, normalizeContentPath(route)]));
+  }
+  const entries = Object.entries(route).filter(([, mount]) => typeof mount === "string" && mount.length > 0).map(([locale, mount]) => [locale, normalizeContentPath(mount)]);
+  return entries.length ? Object.fromEntries(entries) : void 0;
+};
+export const longestMountForPath = (path, mounts) => {
+  const normalized = normalizeContentPath(path);
+  return Object.entries(mounts).filter(([, mount]) => normalized === mount || normalized.startsWith(`${mount}/`)).sort((a, b) => b[1].length - a[1].length)[0];
+};
+export const routeRemainder = (path, mount) => {
+  const normalizedPath = normalizeContentPath(path);
+  const normalizedMount = normalizeContentPath(mount);
+  if (normalizedPath === normalizedMount) {
+    return "/";
+  }
+  return normalizeContentPath(normalizedPath.slice(normalizedMount.length) || "/");
+};
+export const mountContentPath = (remainder, locale, mounts) => {
+  const mount = locale && mounts?.[locale];
+  if (!mount) {
+    return normalizeContentPath(remainder);
+  }
+  const suffix = normalizeContentPath(remainder);
+  return normalizeContentPath(suffix === "/" ? mount : `${mount}${suffix}`);
+};
+const isLocalePrefixedPath = (path, locales) => {
+  const segments = path.split("/").filter(Boolean);
+  return Boolean(segments[0] && locales.includes(segments[0]));
+};
+export const prefixPathWithLocale = (path, locale, defaultLocale) => {
+  const normalizedPath = normalizeContentPath(path || "/");
+  if (!locale || locale === defaultLocale) {
+    return normalizedPath;
+  }
+  return normalizedPath === "/" ? `/${locale}` : `/${locale}${normalizedPath}`;
+};
+export const stripLocalePrefix = (path, locales = [], defaultLocale, explicitLocale) => {
+  const normalized = normalizeContentPath(path);
+  const segments = normalized.split("/").filter(Boolean);
+  const routeLocale = segments[0] && locales.includes(segments[0]) && segments[0] !== defaultLocale ? segments[0] : void 0;
+  const locale = explicitLocale && locales.includes(explicitLocale) ? explicitLocale : routeLocale || defaultLocale;
+  const routePath = routeLocale ? normalizeContentPath("/" + segments.slice(1).join("/")) : normalized;
+  return { locale, path: routePath };
+};
+export const routeToContentPathCandidates = (route, requestedLocale, localeChain, defaultLocale, mounts) => {
+  const locales = Array.from(new Set([...Object.keys(mounts || {}), ...localeChain, defaultLocale].filter(Boolean)));
+  const stripped = stripLocalePrefix(route, locales, defaultLocale, requestedLocale);
+  if (!mounts) {
+    return localeChain.map((locale) => ({ locale, path: stripped.path }));
+  }
+  const activeLocale = stripped.locale || requestedLocale || defaultLocale;
+  const activeMount = activeLocale ? mounts[activeLocale] : void 0;
+  const matchedMount = activeMount && (stripped.path === activeMount || stripped.path.startsWith(`${activeMount}/`)) ? activeMount : longestMountForPath(stripped.path, mounts)?.[1];
+  const remainder = matchedMount ? routeRemainder(stripped.path, matchedMount) : stripped.path;
+  return localeChain.map((locale) => ({
+    locale,
+    path: mountContentPath(remainder, locale, mounts)
+  }));
+};
+export const projectContentPathToLocale = (path, locale, defaultLocale, mounts) => {
+  const normalizedPath = normalizeContentPath(path || "/");
+  if (normalizedPath === "/") {
+    return prefixPathWithLocale(normalizedPath, locale, defaultLocale);
+  }
+  if (!locale || !mounts) {
+    return prefixPathWithLocale(normalizedPath, locale, defaultLocale);
+  }
+  const source = longestMountForPath(normalizedPath, mounts);
+  const remainder = source ? routeRemainder(normalizedPath, source[1]) : normalizedPath;
+  return prefixPathWithLocale(mountContentPath(remainder, locale, mounts), locale, defaultLocale);
+};
+export const pathHasLocalePrefix = isLocalePrefixedPath;

package/dist/core/content/slug

@@ -0,0 +1 @@
+export * from './slug.js'

package/dist/core/content/slug.d.ts

@@ -0,0 +1,4 @@
+export interface SlugifyUrlSegmentOptions {
+    lower?: boolean;
+}
+export declare function slugifyUrlSegment(value: string, options?: SlugifyUrlSegmentOptions): string;

package/dist/core/content/slug.js

@@ -0,0 +1,41 @@
+const transliterations = {
+  "\xC4": "Ae",
+  "\xD6": "Oe",
+  "\xDC": "Ue",
+  "\u1E9E": "SS",
+  "\xE4": "ae",
+  "\xF6": "oe",
+  "\xFC": "ue",
+  "\xDF": "ss",
+  "\xC6": "AE",
+  "\u01FC": "AE",
+  "\xE6": "ae",
+  "\u01FD": "ae",
+  "\u0152": "OE",
+  "\u0153": "oe",
+  "\xD0": "D",
+  "\xF0": "d",
+  "\u0110": "D",
+  "\u0111": "d",
+  "\u0126": "H",
+  "\u0127": "h",
+  "\u0131": "i",
+  "\u0138": "k",
+  "\u0141": "L",
+  "\u0142": "l",
+  "\u0149": "n",
+  "\u014A": "N",
+  "\u014B": "n",
+  "\xD8": "O",
+  "\xF8": "o",
+  "\xDE": "Th",
+  "\xFE": "th",
+  "\u0166": "T",
+  "\u0167": "t"
+};
+export function slugifyUrlSegment(value, options = {}) {
+  const lower = options.lower ?? true;
+  const source = lower ? value.toLowerCase() : value;
+  const normalized = Array.from(source, (character) => transliterations[character] ?? character).join("");
+  return normalized.replace(/&/g, " and ").replace(/\+/g, " plus ").replace(/@/g, " at ").replace(/['\u2019`´]/g, "").normalize("NFD").replace(/[\u0300-\u036F]/g, "").replace(lower ? /[^a-z0-9]+/g : /[^a-z0-9]+/gi, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}

package/dist/core/content/sources

@@ -0,0 +1 @@
+export * from './sources.js'

package/dist/core/content/sources.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeCollectionSources(source: string | string[]): string[];
+export declare function normalizeCollectionExcludes(exclude: string | string[] | undefined): string[];

package/dist/core/content/sources.js

@@ -0,0 +1,6 @@
+export function normalizeCollectionSources(source) {
+  return Array.isArray(source) ? source : [source];
+}
+export function normalizeCollectionExcludes(exclude) {
+  return exclude ? normalizeCollectionSources(exclude) : [];
+}

package/dist/core/errors

@@ -0,0 +1 @@
+export * from './errors.js'

package/dist/core/errors.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Typed error envelope for the content pipeline.
+ *
+ * Every expected-failure path in `core/`, `storage/`, and `integrations/` emits
+ * a `ContentError` with one of the codes below. Boundary code (HTTP handler,
+ * CLI) maps codes to user-facing responses; tests pattern-match on `.code`.
+ */
+export type ContentErrorCode = 'PARSE_FAILED' | 'TRANSFORM_FAILED' | 'VALIDATION_FAILED' | 'INVALID_CONTENT' | 'DUPLICATE_CANONICAL_ID' | 'DUPLICATE_LOCALIZED_PATH' | 'CONFLICTING_REFS' | 'INVALID_REF_VALUE' | 'INVALID_NAVIGATION_YAML' | 'SCHEMA_VALIDATION_FAILED' | 'CONFLICTING_COLLECTION_MATCH' | 'TRANSLATED_SLUG_CONFLICT';
+export declare class ContentError extends Error {
+    readonly code: ContentErrorCode;
+    readonly context: Record<string, unknown>;
+    constructor(code: ContentErrorCode, message: string, context?: Record<string, unknown>, options?: {
+        cause?: unknown;
+    });
+}

package/dist/core/errors.js

@@ -0,0 +1,10 @@
+export class ContentError extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}, options) {
+    super(message, options);
+    this.name = "ContentError";
+    this.code = code;
+    this.context = context;
+  }
+}

package/dist/core/markdown/tree

@@ -0,0 +1 @@
+export * from './tree.js'

package/dist/core/markdown/tree.d.ts

@@ -0,0 +1,9 @@
+import type { MarkdownNode, MarkdownRoot, Toc } from '../../types/content';
+type ComarkTupleNode = string | [string | null, Record<string, unknown>, ...ComarkTupleNode[]];
+export declare function isMarkdownRoot(value: unknown): value is MarkdownRoot;
+export declare function toMarkdownNode(node: ComarkTupleNode): MarkdownNode;
+export declare function toMarkdownRoot(nodes: ComarkTupleNode[], toc?: Toc): MarkdownRoot;
+export declare function mapMarkdownNodes(nodes: MarkdownNode[], mapNode: (node: MarkdownNode) => MarkdownNode): MarkdownNode[];
+export declare function mapMarkdownNode(node: MarkdownNode, mapNode: (node: MarkdownNode) => MarkdownNode): MarkdownNode;
+export declare function extractMarkdownText(node: MarkdownNode, ignoredTags?: string[]): string;
+export {};

package/dist/core/markdown/tree.js

@@ -0,0 +1,47 @@
+export function isMarkdownRoot(value) {
+  return Boolean(
+    value && typeof value === "object" && value.type === "root" && Array.isArray(value.children)
+  );
+}
+export function toMarkdownNode(node) {
+  if (typeof node === "string") {
+    return {
+      type: "text",
+      value: node
+    };
+  }
+  const [tag, props = {}, ...children] = node;
+  return {
+    type: "element",
+    tag: tag || void 0,
+    props: { ...props },
+    children: children.map((child) => toMarkdownNode(child))
+  };
+}
+export function toMarkdownRoot(nodes, toc) {
+  return {
+    type: "root",
+    children: nodes.map((node) => toMarkdownNode(node)),
+    ...toc ? { toc } : {}
+  };
+}
+export function mapMarkdownNodes(nodes, mapNode) {
+  return nodes.map((node) => mapMarkdownNode(node, mapNode));
+}
+export function mapMarkdownNode(node, mapNode) {
+  const next = {
+    ...node,
+    props: node.props ? { ...node.props } : void 0,
+    children: node.children?.map((child) => mapMarkdownNode(child, mapNode))
+  };
+  return mapNode(next);
+}
+export function extractMarkdownText(node, ignoredTags = []) {
+  if (node.type === "text") {
+    return node.value || "";
+  }
+  if (ignoredTags.includes(node.tag || "")) {
+    return "";
+  }
+  return (node.children || []).map((child) => extractMarkdownText(child, ignoredTags)).join("");
+}

package/dist/core/query/builder

@@ -0,0 +1 @@
+export * from './builder.js'

package/dist/core/query/builder.d.ts

@@ -0,0 +1,18 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentQueryBuilder, ContentQueryBuilderParams, ContentQueryFetcher } from '../../types/query';
+interface QueryOptions {
+    initialParams?: ContentQueryBuilderParams;
+}
+export declare function createQuery<T = ParsedContent>(fetcher: ContentQueryFetcher<T>, opts?: QueryOptions): ContentQueryBuilder<T>;
+/**
+ * Wrap a query builder so every `.params()` result passes through `transform`
+ * and every chainable return value is itself wrapped. The wrapper is a Proxy —
+ * it does not mutate or patch the underlying builder, so the immutable
+ * guarantee above holds end-to-end.
+ *
+ * Adapters use this to layer transport-specific normalization (server: inject
+ * active locale from request context; app: resolve draft filter from
+ * `import.meta.dev`) without coupling the pure core builder to either transport.
+ */
+export declare const wrapQueryBuilder: <T = ParsedContent>(inner: ContentQueryBuilder<T>, transform: (params: ContentQueryBuilderParams) => ContentQueryBuilderParams) => ContentQueryBuilder<T>;
+export {};

package/dist/core/query/builder.js

@@ -0,0 +1,186 @@
+import { ensureArray } from "./operators.js";
+const resolveQueryResult = (result) => {
+  if (!result) {
+    return result;
+  }
+  if (typeof result === "object" && "result" in result) {
+    return result.result;
+  }
+  return result;
+};
+const arrayParams = ["sort", "where", "only", "without"];
+const buildCondition = (field, operator, value) => {
+  switch (operator) {
+    case "=":
+      return { [field]: value };
+    case "!=":
+      return { [field]: { $ne: value } };
+    case ">":
+      return { [field]: { $gt: value } };
+    case ">=":
+      return { [field]: { $gte: value } };
+    case "<":
+      return { [field]: { $lt: value } };
+    case "<=":
+      return { [field]: { $lte: value } };
+    case "IN":
+      return { [field]: { $in: value } };
+    case "NOT IN":
+      return { [field]: { $not: { $in: value } } };
+    case "CONTAINS":
+      return { [field]: { $contains: value } };
+    case "CONTAINS_ANY":
+      return { [field]: { $containsAny: value } };
+    case "REGEX":
+      return { [field]: { $regex: value } };
+    case "ICONTAINS":
+      return { [field]: { $icontains: value } };
+    case "EXISTS":
+      return { [field]: { $exists: value ?? true } };
+    case "TYPE":
+      return { [field]: { $type: value } };
+    default:
+      throw new TypeError(`Unsupported content query operator: ${operator}`);
+  }
+};
+const appendWhere = (params, condition) => {
+  const existing = Array.isArray(params.where) ? params.where : params.where ? [params.where] : [];
+  return [...existing, condition];
+};
+const appendSort = (params, field, direction, options = {}) => {
+  const existing = Array.isArray(params.sort) ? params.sort : params.sort ? [params.sort] : [];
+  return [
+    ...existing,
+    {
+      [field]: direction === "DESC" ? -1 : 1,
+      ...options.locale ? { $locale: options.locale } : {},
+      ...typeof options.numeric === "boolean" ? { $numeric: options.numeric } : {},
+      ...options.caseFirst ? { $caseFirst: options.caseFirst } : {},
+      ...options.sensitivity ? { $sensitivity: options.sensitivity } : {}
+    }
+  ];
+};
+const buildGroup = () => {
+  const conditions = [];
+  const pushCondition = (condition) => {
+    conditions.push(condition);
+    return group;
+  };
+  const wrap = (type, groupFactory) => {
+    const nested = buildGroup();
+    groupFactory(nested);
+    const condition = nested.toCondition(type);
+    if (condition) {
+      conditions.push(condition);
+    }
+    return group;
+  };
+  const group = {
+    where: (field, operator, value) => pushCondition(buildCondition(String(field), operator, value)),
+    andWhere: (groupFactory) => wrap("$and", groupFactory),
+    orWhere: (groupFactory) => wrap("$or", groupFactory),
+    toCondition: (type = "$and") => {
+      if (conditions.length === 0) {
+        return null;
+      }
+      if (conditions.length === 1) {
+        return conditions[0];
+      }
+      return { [type]: conditions };
+    }
+  };
+  return group;
+};
+export function createQuery(fetcher, opts = {}) {
+  const queryParams = {};
+  for (const key of Object.keys(opts.initialParams || {})) {
+    queryParams[key] = arrayParams.includes(key) ? ensureArray(opts.initialParams[key]) : opts.initialParams[key];
+  }
+  const next = (changes) => createQuery(fetcher, { initialParams: { ...queryParams, ...changes } });
+  const query = {
+    params: () => ({
+      ...queryParams,
+      ...queryParams.where ? { where: [...ensureArray(queryParams.where)] } : {},
+      ...queryParams.sort ? { sort: [...ensureArray(queryParams.sort)] } : {}
+    }),
+    where: (field, operator, value) => {
+      const condition = typeof field === "object" && field ? field : buildCondition(field, operator, value);
+      return next({ where: appendWhere(queryParams, condition) });
+    },
+    andWhere: (groupFactory) => {
+      const group = buildGroup();
+      groupFactory(group);
+      const resolved = group.toCondition();
+      return resolved ? next({ where: appendWhere(queryParams, resolved) }) : query;
+    },
+    orWhere: (groupFactory) => {
+      const group = buildGroup();
+      groupFactory(group);
+      const resolved = group.toCondition("$or");
+      return resolved ? next({ where: appendWhere(queryParams, resolved) }) : query;
+    },
+    select: (...fields) => {
+      const only = Array.isArray(queryParams.only) ? queryParams.only : queryParams.only ? [queryParams.only] : [];
+      return next({ only: [...only, ...fields] });
+    },
+    order: (field, direction, options) => {
+      return next({ sort: appendSort(queryParams, field, direction, options) });
+    },
+    limit: (value) => next({ limit: parseInt(String(value), 10) }),
+    skip: (value) => next({ skip: parseInt(String(value), 10) }),
+    // Terminal methods: build a transient snapshot with the terminal flag and
+    // hand it to the fetcher. We deliberately do NOT mutate `queryParams` — so
+    // calling `.first()` on a shared base query does not leak `first: true`
+    // back into subsequent `.count()` / `.all()` calls on that same base.
+    //
+    // These are non-arrow methods so `this` binds to the call site's receiver.
+    // When a `wrapQueryBuilder` Proxy wraps this builder, the Proxy is the
+    // receiver — so `this.params()` flows through the Proxy's transform.
+    // Without this, adapter-level normalization (locale injection, draft
+    // filters) would be silently skipped at the terminal methods.
+    all() {
+      return fetcher(this).then(resolveQueryResult);
+    },
+    find() {
+      return fetcher(this).then(resolveQueryResult);
+    },
+    first() {
+      const snapshot = { params: () => ({ ...this.params(), first: true }) };
+      return fetcher(snapshot).then(resolveQueryResult);
+    },
+    count() {
+      const snapshot = { params: () => ({ ...this.params(), count: true }) };
+      return fetcher(snapshot).then(resolveQueryResult);
+    },
+    locale: (_locale, options) => {
+      const filteredWhere = queryParams.where ? ensureArray(queryParams.where).filter((item) => typeof item._locale === "undefined") : void 0;
+      return next({
+        resolveLocale: {
+          locale: _locale,
+          fallback: Array.isArray(options?.fallback) ? options?.fallback : Boolean(options?.fallback),
+          exact: !options?.fallback
+        },
+        ...filteredWhere !== void 0 ? { where: filteredWhere } : {}
+      });
+    }
+  };
+  return query;
+}
+export const wrapQueryBuilder = (inner, transform) => new Proxy(inner, {
+  get(target, key, receiver) {
+    if (key === "params") {
+      return () => transform(target.params());
+    }
+    const value = Reflect.get(target, key, receiver);
+    if (typeof value !== "function") {
+      return value;
+    }
+    return (...args) => {
+      const returned = Reflect.apply(value, receiver, args);
+      if (returned && typeof returned === "object" && "params" in returned && typeof returned.params === "function") {
+        return wrapQueryBuilder(returned, transform);
+      }
+      return returned;
+    };
+  }
+});

package/dist/core/query/execute

@@ -0,0 +1 @@
+export * from './execute.js'

package/dist/core/query/execute.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Executes a `ContentQueryPlan` (see `./plan.ts`) against a content graph.
+ *
+ * Three execution modes, dispatched from `executeQueryPlan`:
+ *
+ *  1. `executeVariantPlan` — the plan requested a specific **route path**,
+ *     so we resolve the variant directly from the graph's route index, then
+ *     pass it through the same filter/projection/finalization path as every
+ *     other query.
+ *  2. `executeLocalePlan` — the plan has a `resolveLocale` term, so we
+ *     filter + sort first, then dedupe by canonical key picking the
+ *     best-ranked locale per document.
+ *  3. `executeStandardPlan` — no locale semantics; filter + sort +
+ *     project + slice.
+ *
+ * Operator dispatch (`compareOperators` below) maps each `CompareOperator`
+ * to a `(item, value) => boolean` comparator. Operand narrowing happens
+ * here via type aliases (`Comparable`, `Haystack`) rather than `as any`.
+ */
+import type { ContentQueryResponse } from '../../types/api';
+import type { ContentGraph } from '../content/graph';
+import type { ContentQueryPlan, FilterExpr } from './plan';
+export declare const evaluateQueryPlanFilter: (item: Record<string, unknown>, filter: FilterExpr) => boolean;
+export declare const applyQueryPlanProjection: <T>(items: T[], plan: ContentQueryPlan) => T[];
+export declare const finalizeQueryPlanResponse: <T>(matched: T[], plan: ContentQueryPlan) => ContentQueryResponse<T>;
+export declare const executeQueryPlanOnDocuments: <T>(documents: T[], plan: ContentQueryPlan) => ContentQueryResponse<T>;
+/**
+ * Top-level dispatcher. Picks the right execution strategy based on the
+ * plan's resolution terms, then returns a uniform `ContentQueryResponse<T>`.
+ */
+export declare const executeQueryPlan: <T>(graph: ContentGraph, plan: ContentQueryPlan, options?: {
+    defaultLocale?: string;
+    localeFallback?: Record<string, string[]>;
+    collections?: Record<string, {
+        route?: string | Record<string, string>;
+        i18n?: boolean | {
+            locales?: string[];
+            defaultLocale?: string;
+        };
+    }>;
+}) => ContentQueryResponse<T>;
+export declare const resolveQueryPlanVariant: (graph: ContentGraph, plan: ContentQueryPlan, options?: {
+    defaultLocale?: string;
+    localeFallback?: Record<string, string[]>;
+    collections?: Record<string, {
+        route?: string | Record<string, string>;
+        i18n?: boolean | {
+            locales?: string[];
+            defaultLocale?: string;
+        };
+    }>;
+}) => import("../../types/runtime").ResolvedVariant | null;