@lupinum/ginko-content 0.1.0

package/dist/parsers/csv

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

package/dist/parsers/csv.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types/content").ContentTransformer;
+export default _default;

package/dist/parsers/csv.js

@@ -0,0 +1,38 @@
+import { defineTransformer } from "./utils.js";
+import { fromCSV } from "./from-csv.js";
+const cellValue = (column) => column.children[0]?.value;
+function toJsonObject(tree) {
+  const [header, ...rows] = tree.children;
+  const columns = (header?.children || []).map((column) => cellValue(column));
+  return rows.map((row) => {
+    return row.children.reduce((record, column, index) => {
+      const key = columns[index];
+      if (typeof key === "string") {
+        record[key] = cellValue(column);
+      }
+      return record;
+    }, {});
+  });
+}
+function toJsonArray(tree) {
+  return tree.children.map((row) => {
+    return row.children.map((column) => cellValue(column));
+  });
+}
+export default defineTransformer({
+  name: "csv",
+  extensions: [".csv"],
+  parse: async (_id, content, options = {}) => {
+    const tree = fromCSV(content, {
+      delimiter: ",",
+      json: true,
+      ...options
+    });
+    const result = options.json === false ? toJsonArray(tree) : toJsonObject(tree);
+    return {
+      _id,
+      _type: "csv",
+      body: result
+    };
+  }
+});

package/dist/parsers/from-csv

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

package/dist/parsers/from-csv.d.ts

@@ -0,0 +1,20 @@
+export interface CsvTextNode {
+    type: 'text';
+    value: string;
+}
+export interface CsvColumnNode {
+    type: 'column';
+    children: CsvTextNode[];
+}
+export interface CsvRowNode {
+    type: 'row';
+    children: CsvColumnNode[];
+}
+export interface CsvRootNode {
+    type: 'root';
+    children: CsvRowNode[];
+}
+export interface CsvParseOptions {
+    delimiter?: string;
+}
+export declare const fromCSV: (value: string, encodingOrOptions?: string | CsvParseOptions, maybeOptions?: CsvParseOptions) => CsvRootNode;

package/dist/parsers/from-csv.js

@@ -0,0 +1,85 @@
+const createColumn = (value) => ({
+  type: "column",
+  children: value ? [{ type: "text", value }] : []
+});
+const createRow = (values) => ({
+  type: "row",
+  children: values.map(createColumn)
+});
+const normalizeDelimiter = (options) => {
+  const delimiter = options?.delimiter || ",";
+  if (delimiter.length !== 1) {
+    throw new Error("CSV delimiter must be a single character");
+  }
+  return delimiter;
+};
+export const fromCSV = (value, encodingOrOptions, maybeOptions) => {
+  const options = typeof encodingOrOptions === "string" ? maybeOptions : encodingOrOptions;
+  const delimiter = normalizeDelimiter(options);
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  let index = 0;
+  const pushField = () => {
+    row.push(field);
+    field = "";
+  };
+  const pushRow = () => {
+    pushField();
+    rows.push(createRow(row));
+    row = [];
+  };
+  while (index < value.length) {
+    const char = value[index];
+    if (quoted) {
+      if (char === '"') {
+        if (value[index + 1] === '"') {
+          field += '"';
+          index += 2;
+          continue;
+        }
+        quoted = false;
+        index += 1;
+        continue;
+      }
+      field += char;
+      index += 1;
+      continue;
+    }
+    if (char === '"') {
+      if (field.length > 0) {
+        throw new Error("Unexpected quote in unquoted CSV field");
+      }
+      quoted = true;
+      index += 1;
+      continue;
+    }
+    if (char === delimiter) {
+      pushField();
+      index += 1;
+      continue;
+    }
+    if (char === "\n" || char === "\r") {
+      pushRow();
+      if (char === "\r" && value[index + 1] === "\n") {
+        index += 2;
+      } else {
+        index += 1;
+      }
+      continue;
+    }
+    field += char;
+    index += 1;
+  }
+  if (quoted) {
+    throw new Error("Cannot close document, a token (`quotedData`) is still open");
+  }
+  if (field.length || row.length || !value.endsWith("\n") && !value.endsWith("\r")) {
+    pushRow();
+  }
+  return {
+    type: "root",
+    children: rows
+  };
+};

package/dist/parsers/index

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

package/dist/parsers/index.d.ts

@@ -0,0 +1,10 @@
+import type { StorageValue } from 'unstorage';
+import type { TransformContentOptions } from '../types/content';
+/**
+ * Parse content file using registered plugins
+ */
+export declare function transformContent(id: string, content: StorageValue, options?: TransformContentOptions): Promise<{
+    _id: string;
+    body: StorageValue;
+}>;
+export { defineTransformer } from './utils';

package/dist/parsers/index.js

@@ -0,0 +1,50 @@
+import { extname } from "pathe";
+import { camelCase } from "scule";
+import csv from "./csv.js";
+import markdown from "./markdown.js";
+import yaml from "./yaml.js";
+import pathMeta from "./path-meta.js";
+import json from "./json.js";
+const TRANSFORMERS = [
+  csv,
+  markdown,
+  json,
+  yaml,
+  pathMeta
+];
+function getParser(ext, additionalTransformers = []) {
+  let parser = additionalTransformers.find((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.parse);
+  if (!parser) {
+    parser = TRANSFORMERS.find((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.parse);
+  }
+  return parser;
+}
+function getTransformers(ext, additionalTransformers = []) {
+  return [
+    ...additionalTransformers.filter((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.transform),
+    ...TRANSFORMERS.filter((p) => ext.match(new RegExp(p.extensions.join("|"), "i")) && p.transform)
+  ];
+}
+export async function transformContent(id, content, options = {}) {
+  const { transformers = [] } = options;
+  const file = { _id: id, body: content };
+  const ext = extname(id);
+  const parser = getParser(ext, transformers);
+  if (!parser) {
+    console.warn(`${ext} files are not supported, "${id}" falling back to raw content`);
+    return file;
+  }
+  const parserOptions = options[camelCase(parser.name)] || {};
+  const parsed = await parser.parse(file._id, file.body, parserOptions);
+  const matchedTransformers = getTransformers(ext, transformers);
+  const result = await matchedTransformers.reduce(async (prev, cur) => {
+    const next = await prev || parsed;
+    const transformOptions = options[camelCase(cur.name)];
+    if (transformOptions === false) {
+      return next;
+    }
+    return cur.transform(next, transformOptions || {});
+  }, Promise.resolve(parsed));
+  return result;
+}
+export { defineTransformer } from "./utils.js";

package/dist/parsers/json

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

package/dist/parsers/json.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types/content").ContentTransformer;
+export default _default;

package/dist/parsers/json.js

@@ -0,0 +1,29 @@
+import { destr } from "destr";
+import { defineTransformer } from "./utils.js";
+export default defineTransformer({
+  name: "Json",
+  extensions: [".json", ".json5"],
+  parse: async (_id, content) => {
+    let parsed;
+    if (typeof content === "string") {
+      if (_id.endsWith("json5")) {
+        parsed = (await import("json5").then((m) => m.default || m)).parse(content);
+      } else if (_id.endsWith("json")) {
+        parsed = destr(content);
+      }
+    } else {
+      parsed = content;
+    }
+    if (Array.isArray(parsed)) {
+      console.warn(`JSON array is not supported in ${_id}, moving the array into the \`body\` key`);
+      parsed = {
+        body: parsed
+      };
+    }
+    return {
+      ...parsed,
+      _id,
+      _type: "json"
+    };
+  }
+});

package/dist/parsers/markdown

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

package/dist/parsers/markdown-plugins

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

package/dist/parsers/markdown-plugins.d.ts

@@ -0,0 +1,3 @@
+import type { ComarkPlugin } from 'comark';
+import type { ResolvedMarkdownPlugin } from '../types/content';
+export declare function resolveMarkdownPlugins(plugins: ResolvedMarkdownPlugin[]): Promise<ComarkPlugin[]>;

package/dist/parsers/markdown-plugins.js

@@ -0,0 +1,58 @@
+import highlightPlugin from "comark/plugins/highlight";
+import summaryPlugin from "comark/plugins/summary";
+import tocPlugin from "comark/plugins/toc";
+const builtinMarkdownPlugins = {
+  breaks: {
+    load: () => loadModule("comark/plugins/breaks")
+  },
+  emoji: {
+    load: () => loadModule("comark/plugins/emoji")
+  },
+  highlight: {
+    load: async () => highlightPlugin
+  },
+  "json-render": {
+    load: () => loadModule("comark/plugins/json-render")
+  },
+  math: {
+    load: () => loadModule("comark/plugins/math")
+  },
+  mermaid: {
+    load: () => loadModule("comark/plugins/mermaid")
+  },
+  punctuation: {
+    load: () => loadModule("comark/plugins/punctuation")
+  },
+  security: {
+    load: () => loadModule("comark/plugins/security")
+  },
+  summary: {
+    load: async () => summaryPlugin
+  },
+  toc: {
+    load: async () => tocPlugin
+  }
+};
+export async function resolveMarkdownPlugins(plugins) {
+  return await Promise.all(plugins.map(async (plugin) => {
+    const factory = await loadMarkdownPluginFactory(plugin.name);
+    return factory(plugin.options);
+  }));
+}
+async function loadMarkdownPluginFactory(name) {
+  const builtin = builtinMarkdownPlugins[name];
+  if (builtin) {
+    return await builtin.load();
+  }
+  return await loadModule(name);
+}
+async function loadModule(specifier) {
+  const imported = await import(
+    /* @vite-ignore */
+    specifier
+  );
+  return resolveModule(imported);
+}
+function resolveModule(imported) {
+  return imported.default || imported;
+}

package/dist/parsers/markdown.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types/content").ContentTransformer;
+export default _default;

package/dist/parsers/markdown.js

@@ -0,0 +1,64 @@
+import { parse } from "comark";
+import { isRelative } from "ufo";
+import { defineTransformer } from "./utils.js";
+import { generatePath } from "./path-meta.js";
+import { resolveMarkdownPlugins } from "./markdown-plugins.js";
+import { mapMarkdownNodes, toMarkdownRoot } from "../core/markdown/tree";
+export default defineTransformer({
+  name: "markdown",
+  extensions: [".md"],
+  parse: async (_id, content, options = {}) => {
+    const config = { ...options };
+    const plugins = await resolveMarkdownPlugins(config.plugins || []);
+    const tree = await parse(content, {
+      plugins
+    });
+    const body = normalizeMarkdownBody({
+      ...toMarkdownRoot(tree.nodes),
+      toc: tree.meta?.toc
+    });
+    const excerpt = Array.isArray(tree.meta?.summary) ? normalizeMarkdownBody({
+      ...toMarkdownRoot(tree.meta.summary)
+    }) : void 0;
+    return {
+      ...tree.frontmatter,
+      _empty: body.children.length === 0,
+      description: typeof tree.frontmatter.description === "string" ? tree.frontmatter.description : "",
+      excerpt,
+      body,
+      _type: "markdown",
+      _id
+    };
+  }
+});
+function normalizeMarkdownBody(body) {
+  return {
+    ...body,
+    children: mapMarkdownNodes(body.children, normalizeMarkdownNode)
+  };
+}
+function normalizeMarkdownNode(node) {
+  if (node.tag !== "a") {
+    return node;
+  }
+  const href = typeof node.props?.href === "string" ? node.props.href : void 0;
+  if (!href) {
+    return node;
+  }
+  return {
+    ...node,
+    props: {
+      ...node.props,
+      href: normalizeLink(href)
+    }
+  };
+}
+function normalizeLink(link) {
+  const match = link.match(/#.+$/);
+  const hash = match ? match[0] : "";
+  if (link.replace(/#.+$/, "").endsWith(".md") && (isRelative(link) || !/^https?/.test(link) && !link.startsWith("/"))) {
+    const normalized = link.replace(".md" + hash, "").replace(/^\.\//, "");
+    return generatePath(normalized, { forceLeadingSlash: false }) + hash;
+  }
+  return link;
+}

package/dist/parsers/path-meta

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

package/dist/parsers/path-meta.d.ts

@@ -0,0 +1,4 @@
+import { describeId, generateCanonicalKey, generatePath, generateTitle, refineUrlPart } from '../core/content/path';
+declare const _default: import("../types/content").ContentTransformer;
+export default _default;
+export { describeId, generateCanonicalKey, generatePath, generateTitle, refineUrlPart };

package/dist/parsers/path-meta.js

@@ -0,0 +1,37 @@
+import { describeId, generateCanonicalKey, generatePath, generateTitle, isDraftPath, isPartialPath, refineUrlPart } from "../core/content/path";
+import { defineTransformer } from "./utils.js";
+export default defineTransformer({
+  name: "path-meta",
+  extensions: [".*"],
+  transform(content, options = {}) {
+    const { locales = [], defaultLocale = "en", respectPathCase = false, translatedSlugs = false } = options;
+    const { _source, _file, _path, _extension, _basename } = describeId(content._id);
+    const parts = _path.split("/");
+    const _locale = locales.includes(parts[0]) ? parts.shift() : defaultLocale;
+    const isNavigation = _basename === ".navigation";
+    const rawPath = isNavigation ? parts.slice(0, -1).join("/") : parts.join("/");
+    const filePath = generatePath(rawPath, { respectPathCase });
+    const _canonicalKey = generateCanonicalKey(isNavigation ? parts.slice(0, -1) : parts, { translatedSlugs, respectPathCase });
+    const _collection = options.collectionResolver?.(_file);
+    return {
+      ...content,
+      // Fallback title synthesis lives here (not in the markdown parser) so it
+      // applies uniformly to every parser output. Moving it into the markdown
+      // parser would duplicate the logic in the yaml / json / csv parsers.
+      title: content.title || (isNavigation ? void 0 : generateTitle(refineUrlPart(_basename))),
+      _path: filePath,
+      _dir: filePath.split("/").slice(-2)[0],
+      _draft: content.draft || isDraftPath(_path),
+      _partial: isNavigation || isPartialPath(_path),
+      _locale,
+      _canonicalKey,
+      _collection,
+      _navigation: isNavigation,
+      _source,
+      _file,
+      _stem: _path,
+      _extension
+    };
+  }
+});
+export { describeId, generateCanonicalKey, generatePath, generateTitle, refineUrlPart };

package/dist/parsers/utils

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

package/dist/parsers/utils.d.ts

@@ -0,0 +1,2 @@
+import type { ContentTransformer } from '../types/content';
+export declare const defineTransformer: (transformer: ContentTransformer) => ContentTransformer;

package/dist/parsers/utils.js

@@ -0,0 +1,3 @@
+export const defineTransformer = (transformer) => {
+  return transformer;
+};

package/dist/parsers/yaml

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

package/dist/parsers/yaml.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types/content").ContentTransformer;
+export default _default;

package/dist/parsers/yaml.js

@@ -0,0 +1,19 @@
+import { load } from "js-yaml";
+import { defineTransformer } from "./utils.js";
+export default defineTransformer({
+  name: "Yaml",
+  extensions: [".yml", ".yaml"],
+  parse: (_id, content) => {
+    const data = load(String(content));
+    let parsed = data;
+    if (Array.isArray(data)) {
+      console.warn(`YAML array is not supported in ${_id}, moving the array into the \`body\` key`);
+      parsed = { body: data };
+    }
+    return {
+      ...parsed,
+      _id,
+      _type: "yaml"
+    };
+  }
+});

package/dist/public/client

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

package/dist/public/client.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Client-side public API surface (browser + SSR Vue).
+ *
+ * The unified query API (ADR-0016) is the supported core read path. Route
+ * pages use the thin `useContentPage` convenience helper built on top of it.
+ */
+export { one, many, paginate, backlinks, resolveOne, variants, tree, neighbors } from '../runtime/app/composables/query-api.js';
+export { getCollectionPath } from '../runtime/query/routes.js';
+export type { CollectionPathOptions } from '../runtime/query/routes.js';
+export { useContentPage, useContentOne, useContentMany, useContentPagination, useContentBacklinks, useContentResolveOne, useContentVariants, useContentTree, useContentNeighbors, useContentLocaleSwitch } from '../runtime/app/composables/use-content.js';
+export type { UseContentPageOptions } from '../runtime/app/composables/use-content.js';
+export type { QueryWhere, QueryOperators, ContentSelector, ContentResolvedMeta, BacklinkFields, BacklinkSource, BacklinksOptions, BacklinksResult, LocaleFallback, DocumentFromHandle, OneOptions, ManyOptions, PaginationOptions, PaginationResult, PopulateSpec, PopulatedDocument, ResolveOneOptions, ResolveOneResult, LocalizedDoc, LocalePathEntry, NeighborsOptions, NeighborsResult, ResolutionEnvelope, SortSpec, TreeOptions, VariantsOptions, ContentVariant, ContentNavigationItem, ContentTreeItem, ContentRouteMeta, ContentSearchSection } from '../types/query.js';
+export { useContentSearch, useContentSearchData, useContentSearchResults } from '../runtime/app/composables/search.js';
+export type { UseContentSearchDataOptions, UseContentSearchDataResult, UseContentSearchOptions, UseContentSearchResult, UseContentSearchResultsOptions, UseContentSearchResultsResult } from '../runtime/app/composables/search.js';
+export { querySiteData } from '../runtime/app/composables/site-data.js';
+export type { ContentSiteDataResponse, QuerySiteDataOptions } from '../runtime/app/composables/site-data.js';
+export { extractContentToc, useContentToc } from '../runtime/app/composables/toc.js';
+export type { ContentTocOptions } from '../runtime/app/composables/toc.js';
+export type { ContentSeoImage, ContentSeoMeta, Toc, TocLink } from '../types/content.js';

package/dist/public/client.js

@@ -0,0 +1,26 @@
+export {
+  one,
+  many,
+  paginate,
+  backlinks,
+  resolveOne,
+  variants,
+  tree,
+  neighbors
+} from "../runtime/app/composables/query-api.js";
+export { getCollectionPath } from "../runtime/query/routes.js";
+export {
+  useContentPage,
+  useContentOne,
+  useContentMany,
+  useContentPagination,
+  useContentBacklinks,
+  useContentResolveOne,
+  useContentVariants,
+  useContentTree,
+  useContentNeighbors,
+  useContentLocaleSwitch
+} from "../runtime/app/composables/use-content.js";
+export { useContentSearch, useContentSearchData, useContentSearchResults } from "../runtime/app/composables/search.js";
+export { querySiteData } from "../runtime/app/composables/site-data.js";
+export { extractContentToc, useContentToc } from "../runtime/app/composables/toc.js";

package/dist/public/provider

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

package/dist/public/provider-errors

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

package/dist/public/provider-errors.d.ts

@@ -0,0 +1,4 @@
+export type ContentProviderErrorCode = 'unknown_provider' | 'unknown_collection' | 'unsupported_provider_operation' | 'unsupported_query_operator' | 'unsupported_query_shape' | 'data_collection_route_access' | 'data_collection_search_access' | 'data_collection_sitemap_access' | 'missing_locale_route' | 'provider_config_missing' | 'provider_module_missing' | 'provider_module_invalid' | 'unsupported_provider_search_index' | 'unsupported_provider_search' | 'unsupported_provider_site_data' | 'unsupported_provider_prerender';
+export declare const createContentProviderError: (code: ContentProviderErrorCode, message: string, details?: Record<string, unknown>) => import("h3").H3Error<{
+    code: ContentProviderErrorCode;
+}>;

package/dist/public/provider-errors.js

@@ -0,0 +1,28 @@
+import { createError } from "h3";
+const statusForProviderError = {
+  unknown_provider: 400,
+  unknown_collection: 400,
+  unsupported_provider_operation: 400,
+  unsupported_query_operator: 400,
+  unsupported_query_shape: 400,
+  data_collection_route_access: 400,
+  data_collection_search_access: 400,
+  data_collection_sitemap_access: 400,
+  missing_locale_route: 404,
+  provider_config_missing: 500,
+  provider_module_missing: 500,
+  provider_module_invalid: 500,
+  unsupported_provider_search_index: 400,
+  unsupported_provider_search: 400,
+  unsupported_provider_site_data: 400,
+  unsupported_provider_prerender: 400
+};
+export const createContentProviderError = (code, message, details = {}) => createError({
+  statusCode: statusForProviderError[code],
+  statusMessage: code,
+  message,
+  data: {
+    code,
+    ...details
+  }
+});

package/dist/public/provider.d.ts

@@ -0,0 +1,74 @@
+import type { H3Event } from 'h3';
+import type { ContentQueryResponse } from '../types/api';
+import type { NavItem, ParsedContent } from '../types/content';
+import type { ContentProviderName } from '../types/config';
+import type { ContentCollectionItemSurroundingsOptions, ContentCollectionNavigationOptions, ContentCollectionPageOptions, ContentCollectionRouteMetaOptions, ContentCollectionSearchSectionsOptions, ContentPageResult, ContentQueryBuilderParams, ContentRouteMeta, ContentSearchSection, ContentSitemapEntry } from '../types/query';
+import type { QueryCollectionsSitemapEntriesOptions } from '../features/sitemap/query';
+import type { ContentProviderSearchRequest, ContentSearchResult } from '../types/search';
+export interface ContentCacheHint {
+    tags?: string[];
+    paths?: string[];
+    maxAge?: number;
+    swr?: number;
+    etag?: string;
+    lastModified?: Date;
+}
+export type ContentCacheHintInput = ContentCacheHint | false;
+export declare const contentProviderResultMarker = "__ginkoContentProviderResult";
+export interface ContentProviderResult<T = unknown> {
+    readonly [contentProviderResultMarker]: true;
+    data: T;
+    cache: ContentCacheHintInput;
+}
+export type MaybeContentProviderResult<T = unknown> = T | ContentProviderResult<T>;
+export declare const withContentCache: <T>(data: T, cache: ContentCacheHintInput) => ContentProviderResult<T>;
+export interface ContentCacheInvalidateInput {
+    tags?: string[];
+    paths?: string[];
+}
+export interface ContentCacheAdapter {
+    name: string;
+    apply: (event: H3Event, hint: ContentCacheHint) => void | Promise<void>;
+    invalidate: (input: ContentCacheInvalidateInput) => Promise<void>;
+}
+export interface ContentProviderSiteDataRequest {
+    key: string;
+    locale?: string;
+}
+export interface ContentProviderSiteDataResponse<T = unknown> {
+    key?: string;
+    locale?: string;
+    data?: T | null;
+    updatedAt?: number;
+}
+export interface ContentProviderCapabilities {
+    routeBackedCollections: boolean;
+    dataCollections: boolean;
+    localizedRoutes: boolean;
+    translatedSlugs: boolean;
+    navigation: boolean;
+    surroundings: boolean;
+    searchSections: boolean;
+    sitemap: boolean;
+    query: {
+        operators: string[];
+        limit: boolean;
+        skip: boolean;
+        count: boolean;
+    };
+}
+export interface ContentProvider {
+    name: ContentProviderName;
+    capabilities: ContentProviderCapabilities;
+    query: <T = ParsedContent>(event: H3Event, query: ContentQueryBuilderParams) => Promise<MaybeContentProviderResult<ContentQueryResponse<T> | T[] | T | number | undefined>>;
+    navigationQuery?: (event: H3Event, query: ContentQueryBuilderParams) => Promise<MaybeContentProviderResult<NavItem[]>>;
+    navigation?: (event: H3Event, collection: string, options?: string[] | ContentCollectionNavigationOptions) => Promise<MaybeContentProviderResult<NavItem[]>>;
+    surroundings?: (event: H3Event, collection: string, path: string, options?: ContentCollectionItemSurroundingsOptions) => Promise<MaybeContentProviderResult<Array<NavItem | null>>>;
+    searchSections?: (event: H3Event, collection: string, options?: ContentCollectionSearchSectionsOptions) => Promise<MaybeContentProviderResult<ContentSearchSection[]>>;
+    search?: (event: H3Event, request: ContentProviderSearchRequest) => Promise<MaybeContentProviderResult<ContentSearchResult[]>>;
+    siteData?: <T = unknown>(event: H3Event, request: ContentProviderSiteDataRequest) => Promise<MaybeContentProviderResult<ContentProviderSiteDataResponse<T>>>;
+    page?: <T = ParsedContent>(event: H3Event, collection: string, routeOrPath?: string, options?: ContentCollectionPageOptions) => Promise<MaybeContentProviderResult<ContentPageResult<T> | null>>;
+    routeMeta?: (event: H3Event, collection: string, routeOrPath?: string, options?: ContentCollectionRouteMetaOptions) => Promise<MaybeContentProviderResult<ContentRouteMeta | null>>;
+    sitemapEntries?: (event: H3Event, options?: QueryCollectionsSitemapEntriesOptions) => Promise<MaybeContentProviderResult<ContentSitemapEntry[]>>;
+    invalidate?: (event: H3Event, input: ContentCacheInvalidateInput) => Promise<void>;
+}