@lupinum/ginko-content 0.1.2 → 0.1.4

package/dist/types/config.d.ts

@@ -63,6 +63,68 @@ export interface ContentCmsCollectionConfig {
     fields?: Record<string, ContentCmsFieldConfig>;
     settings?: unknown;
 }
+export declare const agentMetadataFields: readonly ["title", "description", "url", "route", "locale", "section", "collection", "source", "updated"];
+export type AgentMetadataField = typeof agentMetadataFields[number];
+export type AgentMetadataFieldList = readonly AgentMetadataField[];
+export declare function defineAgentMetadataFields<const TFields extends AgentMetadataFieldList>(fields: TFields): TFields;
+export interface ContentAgentMarkdownOptions {
+    includeInIndex?: boolean;
+    includeInFull?: boolean;
+    metadata?: AgentMetadataFieldList;
+}
+export interface ContentAgentCollectionConfig {
+    section?: string;
+    markdown?: boolean | ContentAgentMarkdownOptions;
+}
+export type ContentAgentLocalizedValue = string | Record<string, string>;
+export interface ContentAgentSiteConfig {
+    title: ContentAgentLocalizedValue;
+    description: ContentAgentLocalizedValue;
+    url?: string;
+    defaultLocale?: string;
+    locales?: string[];
+    profile?: string;
+    contentSignals?: {
+        search?: boolean;
+        aiInput?: boolean;
+        aiTrain?: boolean;
+    };
+}
+export interface ContentAgentMarkdownMetadataConfig {
+    enabled?: boolean;
+    defaultFields?: AgentMetadataFieldList;
+}
+export interface ContentAgentMarkdownPolicyConfig {
+    metadata?: boolean | AgentMetadataFieldList | ContentAgentMarkdownMetadataConfig;
+}
+export interface ContentAgentSectionConfig {
+    id: string;
+    title: ContentAgentLocalizedValue;
+    order?: number;
+}
+export interface ContentAgentAppPageContext {
+    locale: string;
+    defaultLocale?: string;
+    siteUrl: string;
+}
+export interface ContentAgentAppPageConfig {
+    id: string;
+    route: ContentAgentLocalizedValue;
+    section: string;
+    title: ContentAgentLocalizedValue | ((ctx: ContentAgentAppPageContext) => string | Promise<string>);
+    description: ContentAgentLocalizedValue | ((ctx: ContentAgentAppPageContext) => string | Promise<string>);
+    updated?: string;
+    includeInIndex?: boolean;
+    includeInFull?: boolean;
+    metadata?: AgentMetadataFieldList;
+    render: (ctx: ContentAgentAppPageContext) => string | Promise<string>;
+}
+export interface ContentAgentConfig {
+    site?: ContentAgentSiteConfig;
+    markdown?: ContentAgentMarkdownPolicyConfig;
+    sections?: ContentAgentSectionConfig[];
+    pages?: ContentAgentAppPageConfig[];
+}
 /**
  * Object source shape accepted for Nuxt Content v3 migration.
  */
@@ -136,6 +198,12 @@ export interface ContentCollectionConfig<TSchema extends ZodType | undefined = Z
      * source, i18n, and schema information.
      */
     cms?: ContentCmsCollectionConfig;
+    /**
+     * Agent-facing collection exposure. Collections declare only whether pages
+     * produce normalized markdown and which agent section they belong to. Root
+     * `agent` config owns site policy; the Ginko module owns route plumbing.
+     */
+    agent?: ContentAgentCollectionConfig;
 }
 export type ContentProviderName = 'filesystem' | (string & {});
 export type DefineCollectionOptions<TSchema extends ZodType | undefined = ZodType | undefined> = Omit<ContentCollectionConfig<TSchema>, 'source' | 'exclude'>;
@@ -167,6 +235,12 @@ export interface ContentConfig<TCollections extends Record<string, ContentCollec
      * modules register themselves, so app configs usually do not need this.
      */
     providers?: Record<string, string>;
+    /**
+     * Agent-facing site map and markdown output. Ginko owns the repetitive
+     * `/llms.txt`, raw markdown, and static route plumbing; apps provide site
+     * facts and app-owned page renderers here.
+     */
+    agent?: ContentAgentConfig;
     /**
      * Named content collections keyed by the identifier used at query time.
      */
@@ -274,6 +348,9 @@ export declare function defineContentConfig<const TCollections extends Record<st
     collections: TCollections;
 }): NamedContentConfig<TCollections>;
 export declare function defineContentConfig<const TConfig extends ContentConfig<Record<string, ContentCollectionConfig>>>(config: TConfig): TConfig;
+export declare function defineAgentSection<const TConfig extends ContentAgentSectionConfig>(config: TConfig): TConfig;
+export declare function defineAgentAppPage<const TConfig extends ContentAgentAppPageConfig>(config: TConfig): TConfig;
+export declare function defineAgentMarkdownPolicy<const TConfig extends ContentAgentMarkdownPolicyConfig>(config: TConfig): TConfig;
 /**
  * Declare a schema field that stores a reference to another content entry.
  *

package/dist/types/config.js

@@ -1,5 +1,19 @@
 import { z } from "zod";
 import { CONTENT_REFERENCE_PREFIX } from "./reference.js";
+export const agentMetadataFields = [
+  "title",
+  "description",
+  "url",
+  "route",
+  "locale",
+  "section",
+  "collection",
+  "source",
+  "updated"
+];
+export function defineAgentMetadataFields(fields) {
+  return fields;
+}
 export function defineCollection(config) {
   if (typeof config === "string" || arguments.length > 1) {
     throw new TypeError("@lupinum/ginko-content defineCollection(name, config) was removed. Use defineCollection({ ... }) under the desired defineContentConfig({ collections: { docs: ... } }) map key.");
@@ -47,6 +61,15 @@ export function defineContentConfig(config) {
   }
   return config;
 }
+export function defineAgentSection(config) {
+  return config;
+}
+export function defineAgentAppPage(config) {
+  return config;
+}
+export function defineAgentMarkdownPolicy(config) {
+  return config;
+}
 export function reference(collection) {
   return z.string().describe(`${CONTENT_REFERENCE_PREFIX}${collection || ""}`);
 }

package/dist/types/module.d.ts

@@ -1,5 +1,4 @@
-import type { ListenOptions } from 'listhen';
-import type { MarkdownPluginDescriptor } from './content';
+import type { MarkdownOptions, MarkdownPluginDescriptor } from './content';
 import type { ContentCollectionConfig, ContentProviderName } from './config';
 import type { ContentQueryBuilderWhere } from './query';
 import type { ContentMiniSearchOptions, ContentSearchEngine } from './search';
@@ -265,6 +264,12 @@ export interface ContentRevalidateOptions {
      */
     allowUnsigned?: boolean;
 }
+export interface ContentAgentRouteOptions {
+    routes?: boolean;
+    linkHeaders?: boolean;
+    markdownNegotiation?: boolean;
+    prerender?: boolean;
+}
 export interface ModuleOptions {
     api: {
         /**
@@ -308,6 +313,10 @@ export interface ModuleOptions {
      * `x-ginko-revalidate-token` or `authorization: Bearer <token>`.
      */
     revalidate?: false | ContentRevalidateOptions;
+    /**
+     * First-class agent markdown and LLM route features.
+     */
+    agent?: false | ContentAgentRouteOptions;
     /**
      * Optional server-side cache adapter module.
      *
@@ -321,9 +330,7 @@ export interface ModuleOptions {
      *
      * @default true
      */
-    watch: false | {
-        ws: Partial<ListenOptions>;
-    };
+    watch: boolean;
     /**
      * Contents can be located in multiple places, in multiple directories or even in remote git repositories.
      * Using sources option you can tell Content module where to look for contents.
@@ -459,3 +466,6 @@ export interface ContentContext extends ModuleOptions {
     translatedSlugs: boolean;
     strictTranslatedSlugs: boolean;
 }
+export type ResolvedContentContext = Omit<ContentContext, 'markdown'> & {
+    markdown: MarkdownOptions;
+};

package/dist/types/query-parts/collections

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

package/dist/types/query-parts/collections.d.ts

@@ -0,0 +1,15 @@
+import type { ContentCollectionHandle } from '../config';
+declare global {
+    interface GinkoContentCollectionMap {
+    }
+    interface GinkoContentCollectionI18nMap {
+    }
+}
+export interface ContentCollectionMap extends GinkoContentCollectionMap {
+}
+export interface ContentCollectionI18nMap extends GinkoContentCollectionI18nMap {
+}
+export type ContentCollectionName = keyof GinkoContentCollectionMap & string;
+export type ContentCollectionItem<K extends ContentCollectionName> = ContentCollectionMap[K];
+export type ContentCollectionStringName = [ContentCollectionName] extends [never] ? string : ContentCollectionName;
+export type ContentCollectionTarget = ContentCollectionHandle | ContentCollectionStringName;

package/dist/types/query-parts/public

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

package/dist/types/query-parts/public.d.ts

@@ -0,0 +1,202 @@
+import type { ContentNavigationItem, ParsedContent, ParsedContentMeta, StrictParsedContent, StrictParsedContentMeta } from '../content';
+import type { ContentCollectionI18nMap, ContentCollectionMap, ContentCollectionName, ContentCollectionTarget } from './collections';
+import type { ContentRouteMeta, LocalePathEntry } from './results';
+export interface QueryOperators<TValue = unknown> {
+    $eq?: TValue;
+    $ne?: TValue;
+    $gt?: TValue;
+    $gte?: TValue;
+    $lt?: TValue;
+    $lte?: TValue;
+    $in?: TValue[];
+    $nin?: TValue[];
+    $exists?: boolean;
+    $contains?: TValue | TValue[];
+    $containsAny?: TValue[];
+    $icontains?: string;
+    $type?: 'string' | 'number' | 'boolean' | 'object' | 'undefined';
+    $prefix?: TValue extends string ? string : never;
+    $not?: TValue | QueryOperators<TValue>;
+}
+export type ContentSelector = {
+    path: string;
+    route?: never;
+    ref?: never;
+} | {
+    route: string;
+    path?: never;
+    ref?: never;
+} | {
+    ref: string;
+    path?: never;
+    route?: never;
+};
+type WhereValue<T> = T | QueryOperators<T>;
+type PathWhere = string | QueryOperators<string>;
+export type QueryWhere<T = ParsedContentMeta> = {
+    path?: PathWhere;
+    $and?: QueryWhere<T>[];
+    $or?: QueryWhere<T>[];
+    $not?: QueryWhere<T>;
+} & {
+    [K in Exclude<keyof T, 'path'>]?: WhereValue<NonNullable<T[K]>>;
+};
+export type SortDirection = 'asc' | 'desc' | 1 | -1;
+export type SortSpec<T = ParsedContentMeta> = string extends keyof T ? {
+    [key: string]: SortDirection | undefined;
+} : {
+    [K in keyof T]?: SortDirection;
+};
+type HandleSchema<H> = H extends {
+    __schema: infer S;
+} ? S extends {
+    _output: infer O;
+} ? O & StrictParsedContentMeta : StrictParsedContentMeta : H extends ContentCollectionName ? ContentCollectionMap[H] & StrictParsedContentMeta : StrictParsedContentMeta;
+type SelectFields<H> = string extends H ? ReadonlyArray<string> : ReadonlyArray<Extract<keyof HandleSchema<H>, string>>;
+export type DocumentFromHandle<H> = H extends {
+    __schema: {
+        _output: infer O;
+    };
+} ? O & StrictParsedContent : H extends ContentCollectionName ? ContentCollectionMap[H] : ParsedContent;
+export type PopulateSpec = Record<string, ContentCollectionTarget>;
+export type PopulatedDocument<T, P> = P extends undefined ? T : P extends PopulateSpec ? string extends keyof P ? T : Omit<T, keyof P> & {
+    [K in keyof P & keyof T]: T[K] extends ReadonlyArray<unknown> ? Array<LocalizedDoc<DocumentFromHandle<P[K]>>> : LocalizedDoc<DocumentFromHandle<P[K]>> | null;
+} : T;
+export type PopulateFromOptions<O> = O extends {
+    populate?: infer P;
+} ? P : undefined;
+type PopulateOption<P extends PopulateSpec | undefined = undefined> = {
+    populate?: P;
+};
+type HandleIsI18n<H> = H extends {
+    __i18n: infer I;
+} ? I extends true ? true : false : H extends keyof ContentCollectionI18nMap ? true : false;
+type LocaleOption<H, OptKey extends string = 'locale'> = HandleIsI18n<H> extends true ? {
+    [K in OptKey]: string;
+} : {
+    [K in OptKey]?: string;
+};
+type SourceIsI18n<S> = S extends ReadonlyArray<infer I> ? true extends HandleIsI18n<I> ? true : false : HandleIsI18n<S>;
+type BacklinksLocaleOption<Target, Source> = HandleIsI18n<Target> extends true ? {
+    locale: string;
+} : SourceIsI18n<Source> extends true ? {
+    locale: string;
+} : {
+    locale?: string;
+};
+export type LocaleFallback = false | true | 'default' | string | string[];
+export type LocalizedContentDocument<T = ParsedContentMeta> = T & ContentRouteMeta & {
+    locale: string;
+    path: string;
+    canonicalPath: string;
+    localePaths: Record<string, LocalePathEntry>;
+    stem?: string;
+    extension?: string;
+};
+export type LocalizedDoc<T = ParsedContentMeta> = LocalizedContentDocument<T>;
+export interface ResolutionEnvelope {
+    requested: {
+        collection: string;
+        by: ContentSelector;
+        locale?: string;
+        fallback?: LocaleFallback;
+    };
+    normalized: {
+        by: ContentSelector;
+    };
+    matched: {
+        found: boolean;
+        collection: string;
+        path?: string;
+        canonicalPath?: string;
+        ref?: string;
+        locale?: string;
+    };
+    fallback: {
+        used: boolean;
+        locale?: string;
+    };
+}
+export interface ResolveOneResult<T = ParsedContentMeta> {
+    doc: LocalizedDoc<T> | null;
+    explain: ResolutionEnvelope;
+}
+export type ResolveOneOptions<H = unknown, P extends PopulateSpec | undefined = undefined> = {
+    by: ContentSelector;
+    fallback?: LocaleFallback;
+    select?: SelectFields<H>;
+} & LocaleOption<H> & PopulateOption<P>;
+export type OneOptions<H = unknown, P extends PopulateSpec | undefined = undefined> = ResolveOneOptions<H, P>;
+export type ManyOptions<H = unknown, P extends PopulateSpec | undefined = undefined> = {
+    where?: QueryWhere<HandleSchema<H>>;
+    sort?: SortSpec<HandleSchema<H>>;
+    limit?: number;
+    skip?: number;
+    fallback?: LocaleFallback;
+    select?: SelectFields<H>;
+} & LocaleOption<H> & PopulateOption<P>;
+export type PaginationOptions<H = unknown, P extends PopulateSpec | undefined = undefined> = Omit<ManyOptions<H, P>, 'skip' | 'limit'> & {
+    page?: number;
+    limit?: number;
+};
+export interface PaginationResult<T = ParsedContentMeta> {
+    data: Array<LocalizedDoc<T>>;
+    page: number;
+    limit: number;
+    total: number;
+    pageCount: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+    nextPage: number | null;
+    prevPage: number | null;
+}
+export type BacklinkSource = ContentCollectionTarget;
+type SourceName<S> = S extends string ? S : S extends {
+    name: infer N;
+} ? Extract<N, string> : string;
+export type BacklinkFields<S = BacklinkSource | ReadonlyArray<BacklinkSource>> = ReadonlyArray<string> | Partial<Record<SourceName<S extends ReadonlyArray<infer I> ? I : S>, ReadonlyArray<string>>>;
+type DocumentFromSource<S> = S extends ReadonlyArray<infer I> ? DocumentFromHandle<I> : DocumentFromHandle<S>;
+export type BacklinksOptions<Target = unknown, Source extends BacklinkSource | ReadonlyArray<BacklinkSource> = BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined> = {
+    by: ContentSelector;
+    from: Source;
+    fields?: BacklinkFields<Source>;
+    sort?: SortSpec<DocumentFromSource<Source>>;
+    limit?: number;
+    skip?: number;
+    fallback?: LocaleFallback;
+    select?: string extends Source ? ReadonlyArray<string> : ReadonlyArray<Extract<keyof DocumentFromSource<Source>, string>>;
+} & BacklinksLocaleOption<Target, Source> & PopulateOption<P>;
+export type BacklinksResult<Source extends BacklinkSource | ReadonlyArray<BacklinkSource> = BacklinkSource | ReadonlyArray<BacklinkSource>, P extends PopulateSpec | undefined = undefined> = Array<LocalizedDoc<PopulatedDocument<DocumentFromSource<Source>, P>>>;
+export type VariantsOptions<H = unknown> = {
+    by: ContentSelector;
+    locales?: string[];
+} & LocaleOption<H>;
+export interface ContentVariant<_T = ParsedContentMeta> {
+    locale: string;
+    path: string;
+    translated: boolean;
+    fallback?: string;
+}
+export type TreeOptions<H = unknown, Fields extends ReadonlyArray<keyof HandleSchema<H> | string> | undefined = undefined> = {
+    where?: QueryWhere<HandleSchema<H>>;
+    sort?: SortSpec<HandleSchema<H>>;
+    fields?: Fields;
+    fallback?: LocaleFallback;
+    locale?: string;
+};
+export type ContentTreeItem<T = ParsedContentMeta, Fields extends ReadonlyArray<keyof T | string> | undefined = undefined> = {
+    title: string;
+    path: string;
+    _path?: string;
+    children?: Array<ContentTreeItem<T, Fields>>;
+} & (Fields extends ReadonlyArray<infer K> ? Pick<T, Extract<K, keyof T>> : Record<never, never>);
+export type { ContentNavigationItem };
+export type NeighborsOptions<H = unknown> = {
+    by: ContentSelector;
+    fallback?: LocaleFallback;
+    fields?: SelectFields<H>;
+} & LocaleOption<H>;
+export interface NeighborsResult<T = ParsedContentMeta> {
+    prev: ContentTreeItem<T> | null;
+    next: ContentTreeItem<T> | null;
+}

package/dist/types/query-parts/results

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

package/dist/types/query-parts/results.d.ts

@@ -0,0 +1,95 @@
+import type { ParsedContentMeta } from '../content';
+import type { ContentQueryBuilderWhere } from './transport';
+export interface ContentCollectionNavigationOptions<TField extends string = string> {
+    fields?: TField[];
+    locale?: string;
+    canonical?: boolean;
+}
+export type ContentCollectionItemSurroundingsOptions<TField extends string = string> = ContentCollectionNavigationOptions<TField>;
+export interface ContentCollectionSearchSectionsOptions {
+    ignoredTags?: string[];
+    extraFields?: string[];
+    filterQuery?: ContentQueryBuilderWhere;
+    minHeading?: `h${1 | 2 | 3 | 4 | 5 | 6}`;
+    maxHeading?: `h${1 | 2 | 3 | 4 | 5 | 6}`;
+    locale?: string;
+    canonical?: boolean;
+}
+export interface ContentCollectionPageOptions {
+    locale?: string;
+    fallback?: string[] | boolean;
+    exact?: boolean;
+    canonical?: boolean;
+}
+export interface ContentCollectionRouteMetaOptions {
+    locale?: string;
+    fallback?: string[] | boolean;
+    exact?: boolean;
+}
+export interface ResolveContentReferenceOptions {
+    locale?: string;
+    fallback?: string[] | boolean;
+    exact?: boolean;
+    collection?: string;
+}
+export interface ContentLocaleEntry {
+    canonicalKey: string;
+    locale: string;
+    path?: string;
+}
+export interface ContentLocaleRoute {
+    locale: string;
+    path: string;
+    canonicalPath: string;
+}
+export interface LocalePathEntry {
+    path: string;
+    translated: boolean;
+    fallback?: string;
+}
+export interface ContentResolvedMeta {
+    locale: string;
+    requestedLocale?: string;
+    fallback: boolean;
+    fallbackLocale?: string;
+    path: string;
+    requestedPath?: string;
+    requestedRoute?: string;
+    requestedRef?: string;
+    availableLocales: string[];
+}
+export interface ContentRouteMeta {
+    locale: string;
+    defaultLocale: string;
+    path: string;
+    canonicalPath: string;
+    variants: ContentLocaleRoute[];
+    localePaths: Record<string, LocalePathEntry>;
+    resolved: ContentResolvedMeta;
+}
+export type ContentPageResult<T = ParsedContentMeta> = T & ContentRouteMeta & {
+    stem: string;
+    extension?: string;
+};
+export interface ContentSitemapAlternative {
+    hreflang: string;
+    href: string;
+}
+export interface ContentSitemapImage {
+    loc: string;
+}
+export interface ContentSitemapEntry {
+    loc: string;
+    _sitemap?: string;
+    lastmod?: string;
+    alternatives?: ContentSitemapAlternative[];
+    images?: ContentSitemapImage[];
+}
+export interface ContentSearchSection {
+    id: string;
+    title: string;
+    titles: string[];
+    level: number;
+    content: string;
+    [key: string]: unknown;
+}

package/dist/types/query-parts/transport

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

package/dist/types/query-parts/transport.d.ts

@@ -0,0 +1,103 @@
+import type { ContentQueryResponse } from '../api';
+import type { ParsedContentInternalMeta, ParsedContentMeta } from '../content';
+export interface ContentQuerySortParams {
+    $locale?: string;
+    $numeric?: boolean;
+    $caseFirst?: 'upper' | 'lower' | 'false';
+    $sensitivity?: 'base' | 'accent' | 'case' | 'variant';
+}
+export interface ContentQuerySortFields {
+    [field: string]: -1 | 1;
+}
+export type ContentQuerySortOptions = ContentQuerySortParams | ContentQuerySortFields;
+export interface ContentQueryBuilderWhere extends Partial<Record<keyof ParsedContentInternalMeta, string | number | boolean | RegExp | ContentQueryBuilderWhere>> {
+    $and?: ContentQueryBuilderWhere[];
+    $or?: ContentQueryBuilderWhere[];
+    $not?: string | number | boolean | RegExp | ContentQueryBuilderWhere;
+    $eq?: string | number | boolean | RegExp;
+    $ne?: string | number | boolean | RegExp;
+    $gt?: number | string;
+    $gte?: number | string;
+    $lt?: number | string;
+    $lte?: number | string;
+    $regex?: RegExp | string;
+    $prefix?: string;
+    $type?: string;
+    $exists?: boolean;
+    $contains?: Array<string | number | boolean> | string | number | boolean;
+    $containsAny?: Array<string | number | boolean>;
+    $icontains?: string;
+    $in?: Array<string | number | boolean>;
+    [key: string]: string | number | boolean | RegExp | ContentQueryBuilderWhere | Array<string | number | boolean | ContentQueryBuilderWhere> | undefined;
+}
+export interface ContentQueryBuilderParams {
+    collection?: string;
+    first?: boolean;
+    skip?: number;
+    limit?: number;
+    only?: string[];
+    without?: string[];
+    sort?: ContentQuerySortOptions[];
+    where?: ContentQueryBuilderWhere[] | ContentQueryBuilderWhere;
+    canonical?: boolean;
+    navigationFields?: string[];
+    resolveLocale?: {
+        locale?: string;
+        fallback?: string[] | boolean;
+        exact?: boolean;
+    };
+    [key: string]: unknown;
+}
+type QueryScalar = string | number | boolean | Date;
+type InternalQueryKeys = Extract<keyof ParsedContentInternalMeta, `_${string}`>;
+export type CollectionQueryKey<T> = Extract<keyof T, string> | InternalQueryKeys;
+export type CollectionQueryField<T> = CollectionQueryKey<T>;
+export type CollectionQueryFieldValue<T, K extends CollectionQueryField<T>> = K extends keyof T ? NonNullable<T[K]> : K extends InternalQueryKeys ? NonNullable<ParsedContentInternalMeta[K]> : never;
+type EqualityValue<T> = T extends QueryScalar ? T | RegExp : T;
+type ComparableValue<T> = T extends string | number | Date ? T : never;
+type MembershipValue<T> = T extends Array<infer U> ? Array<U> : T extends QueryScalar ? Array<T> : never;
+type ContainsValue<T> = T extends string ? string : T extends Array<infer U> ? U | Array<U> : never;
+type ContainsAnyValue<T> = T extends Array<infer U> ? Array<U> : never;
+type RegexValue<T> = T extends string ? RegExp | string : never;
+type IContainsValue<T> = T extends string ? string : never;
+type TypeValue = 'string' | 'number' | 'boolean' | 'object' | 'undefined';
+export type CollectionQueryOperator<T> = '=' | '!=' | 'EXISTS' | 'TYPE' | (ComparableValue<T> extends never ? never : '>' | '>=' | '<' | '<=') | (MembershipValue<T> extends never ? never : 'IN' | 'NOT IN') | (ContainsValue<T> extends never ? never : 'CONTAINS') | (ContainsAnyValue<T> extends never ? never : 'CONTAINS_ANY') | (RegexValue<T> extends never ? never : 'REGEX') | (IContainsValue<T> extends never ? never : 'ICONTAINS');
+export type CollectionQueryValue<T, O extends CollectionQueryOperator<T>> = O extends '=' | '!=' ? EqualityValue<T> : O extends '>' | '>=' | '<' | '<=' ? ComparableValue<T> : O extends 'IN' | 'NOT IN' ? MembershipValue<T> : O extends 'CONTAINS' ? ContainsValue<T> : O extends 'CONTAINS_ANY' ? ContainsAnyValue<T> : O extends 'REGEX' ? RegexValue<T> : O extends 'ICONTAINS' ? IContainsValue<T> : O extends 'EXISTS' ? boolean | undefined : O extends 'TYPE' ? TypeValue : never;
+export type QueryOrderDirection = 'ASC' | 'DESC';
+export interface QueryOrderOptions {
+    locale?: string;
+    numeric?: boolean;
+    caseFirst?: ContentQuerySortParams['$caseFirst'];
+    sensitivity?: ContentQuerySortParams['$sensitivity'];
+}
+export interface QueryGroupBuilder<T = ParsedContentMeta> {
+    where<K extends CollectionQueryField<T>, O extends CollectionQueryOperator<CollectionQueryFieldValue<T, K>>>(field: K, operator: O, value?: CollectionQueryValue<CollectionQueryFieldValue<T, K>, O>): QueryGroupBuilder<T>;
+    andWhere(groupFactory: QueryGroupFunction<T>): QueryGroupBuilder<T>;
+    orWhere(groupFactory: QueryGroupFunction<T>): QueryGroupBuilder<T>;
+}
+export type QueryGroupFunction<T = ParsedContentMeta> = (group: QueryGroupBuilder<T>) => QueryGroupBuilder<T>;
+export interface ContentQueryBuilder<T = ParsedContentMeta> {
+    where<K extends CollectionQueryField<T>, O extends CollectionQueryOperator<CollectionQueryFieldValue<T, K>>>(field: K, operator: O, value?: CollectionQueryValue<CollectionQueryFieldValue<T, K>, O>): ContentQueryBuilder<T>;
+    andWhere(groupFactory: QueryGroupFunction<T>): ContentQueryBuilder<T>;
+    orWhere(groupFactory: QueryGroupFunction<T>): ContentQueryBuilder<T>;
+    select<const K extends readonly Extract<keyof T, string>[]>(...fields: K): ContentQueryBuilder<Pick<T, K[number]>>;
+    order<K extends CollectionQueryField<T>>(field: K, direction: QueryOrderDirection, options?: QueryOrderOptions): ContentQueryBuilder<T>;
+    limit(count: number): ContentQueryBuilder<T>;
+    skip(count: number): ContentQueryBuilder<T>;
+    params: () => ContentQueryBuilderParams;
+    locale(locale: string, options?: {
+        fallback?: boolean | string[];
+    }): ContentQueryBuilder<T>;
+    all(): Promise<Array<T>>;
+    first(): Promise<T | undefined>;
+    count(): Promise<number>;
+}
+export interface CollectionQueryBuilder<T = ParsedContentMeta> extends ContentQueryBuilder<T> {
+    select<const K extends readonly Extract<keyof T, string>[]>(...fields: K): CollectionQueryBuilder<Pick<T, K[number]>>;
+}
+export interface ContentQueryRequest {
+    params(): ContentQueryBuilderParams;
+}
+export type ContentQueryFetcher<T> = (query: ContentQueryRequest) => Promise<ContentQueryResponse<T>>;
+export type QueryMatchOperator = (item: unknown, condition: unknown) => boolean;
+export {};