@contentrain/query 4.0.0 → 5.0.1

package/dist/index.d.mts

@@ -1,565 +1,108 @@
-interface IBaseCacheStats {
-    size: number;
-    hits: number;
-    misses: number;
-    lastCleanup: number;
-}
-interface ICacheStats {
-    modelConfigs: number;
-    contents: number;
-    cache: IBaseCacheStats | undefined;
-}
-interface IMemoryCacheOptions {
-    readonly maxSize?: number;
-    readonly defaultTTL?: number;
-}
-
-type LoaderType = 'json' | 'sqlite';
-type RelationType = 'one-to-one' | 'one-to-many';
-type ContentrainStatus = 'publish' | 'draft' | 'private';
-interface ILogger {
-    debug: (message: string, context?: Record<string, unknown>) => void;
-    info: (message: string, context?: Record<string, unknown>) => void;
-    warn: (message: string, context?: Record<string, unknown>) => void;
-    error: (message: string, context?: Record<string, unknown>) => void;
-}
-interface IBaseLoader<TData, TResult> {
-    load: (modelId: string) => Promise<TResult>;
-    resolveRelations: <TRelation>(modelId: string, relationKey: keyof TData, data: TData[]) => Promise<TRelation[]>;
-    clearCache: () => Promise<void>;
-}
-
-interface IBaseJSONRecord {
-    readonly ID: string;
-    readonly createdAt: string;
-    readonly updatedAt: string;
-    readonly status: ContentrainStatus;
-    readonly scheduled: boolean;
-    readonly _relations?: {
-        [key: string]: IBaseJSONRecord | IBaseJSONRecord[];
-    };
-}
-interface IJSONLoaderOptions {
-    readonly contentDir: string;
-    readonly cache?: boolean;
-    readonly ttl?: number;
-    readonly maxCacheSize?: number;
-    readonly defaultLocale?: string;
-    readonly modelTTL?: Record<string, number>;
-}
-interface IJSONContent<TData extends IBaseJSONRecord> {
-    readonly [locale: string]: TData[];
-}
-interface IJSONContentFile<TData extends IBaseJSONRecord> {
-    readonly model: string;
-    readonly locale?: string;
-    readonly data: TData[];
-}
-interface IJSONModelConfig {
-    readonly metadata: {
-        readonly modelId: string;
-        readonly name: string;
-        readonly type: 'JSON';
-        readonly localization: boolean;
-        readonly isServerless: boolean;
-        readonly createdBy: string;
-    };
-    readonly fields: Array<{
-        readonly name: string;
-        readonly fieldId: string;
-        readonly modelId: string;
-        readonly fieldType: string;
-        readonly componentId: string;
-        readonly options: {
-            readonly reference?: {
-                readonly form?: {
-                    readonly reference?: {
-                        readonly value: string;
-                    };
-                };
-            };
-        };
-        readonly validations: Record<string, unknown>;
-    }>;
-}
-interface IJSONLoaderResult<TData extends IBaseJSONRecord> {
-    readonly model: IJSONModelConfig;
-    readonly content: IJSONContent<TData>;
-    readonly assets?: Array<{
-        readonly id: string;
-        readonly name: string;
-        readonly path: string;
-        readonly size: number;
-        readonly type: string;
-        readonly createdAt: string;
-        readonly updatedAt: string;
-    }>;
-}
-interface IJSONContentManager {
-    loadModelContent: <T extends IBaseJSONRecord>(modelId: string, locale?: string) => Promise<IJSONContentFile<T>>;
-    loadAssets: () => Promise<any[]>;
-    getModelLocales: (modelId: string) => Promise<string[]>;
-    loadModelConfig: (modelId: string) => Promise<IJSONModelConfig>;
-}
-interface IJSONRelationConfig {
-    readonly model: string;
-    readonly type: 'one-to-one' | 'one-to-many';
-    readonly foreignKey: string;
-}
-interface IJSONRelationManager {
-    loadRelations: (modelId: string) => Promise<IJSONRelationConfig[]>;
-    resolveRelation: <T extends IBaseJSONRecord, R extends IBaseJSONRecord>(modelId: string, relationField: keyof T, data: T[], locale?: string) => Promise<R[]>;
-}
-
-interface IDBRecord {
-    id: string;
-    created_at: string;
-    updated_at: string;
-    status: ContentrainStatus;
-    scheduled?: boolean;
-    _relations?: {
-        [key: string]: IDBRecord | IDBRecord[];
-    };
-}
-interface IDBTranslationRecord extends IDBRecord {
-    readonly locale: string;
-    readonly [key: string]: unknown;
-}
-interface IDBRelation {
-    readonly id: string;
-    readonly source_model: string;
-    readonly source_id: string;
-    readonly target_model: string;
-    readonly target_id: string;
-    readonly field_id: string;
-    readonly type: 'one-to-one' | 'one-to-many';
-    readonly created_at: string;
-    readonly updated_at: string;
-}
-interface ISQLiteLoaderOptions {
-    databasePath: string;
-    cache?: boolean;
-    maxCacheSize?: number;
-    modelTTL?: number | Record<string, number>;
-    defaultLocale?: string;
-    sorting?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    };
-}
-interface ISQLiteContent<TData extends IDBRecord> {
-    readonly default: TData[];
-    readonly translations?: Record<string, IDBTranslationRecord[]>;
-}
-interface ISQLiteLoaderResult<TData extends IDBRecord> {
-    readonly model: {
-        readonly metadata: {
-            readonly modelId: string;
-            readonly name: string;
-            readonly type: 'SQLite';
-            readonly localization: boolean;
-            readonly isServerless: boolean;
-        };
-        readonly fields: Array<{
-            readonly name: string;
-            readonly fieldId: string;
-            readonly type: string;
-        }>;
-    };
-    readonly content: ISQLiteContent<TData>;
-}
-interface ISQLiteConnection {
-    query: <T>(sql: string, params?: unknown[]) => Promise<T[]>;
-    get: <T>(sql: string, params?: unknown[]) => Promise<T | undefined>;
-    close: () => void;
-}
-interface ISQLiteContentManager {
-    findById: <T extends IDBRecord>(model: string, id: string) => Promise<T | undefined>;
-    findAll: <T extends IDBRecord>(model: string, conditions?: Partial<T>) => Promise<T[]>;
-}
-interface ISQLiteRelationManager {
-    loadRelations: (model: string, sourceIds: string[], fieldId: string) => Promise<IDBRelation[]>;
-    loadRelatedContent: <T extends IDBRecord>(relations: IDBRelation[], locale?: string) => Promise<T[]>;
-    getRelationTypes: (model: string) => Promise<Record<string, 'one-to-one' | 'one-to-many'>>;
-}
-interface ISQLiteTranslationManager {
-    hasTranslations: (model: string) => Promise<boolean>;
-    loadTranslations: (model: string, ids: string[], locale?: string) => Promise<Record<string, IDBTranslationRecord>>;
-    getLocales: (model: string) => Promise<string[]>;
-    getMainColumns: (model: string) => Promise<string[]>;
-    getTranslationColumns: (model: string) => Promise<string[]>;
-}
-
-declare class SQLiteConnection {
-    private readonly db;
-    constructor(databasePath: string);
-    private setupDatabase;
-    query<T>(sql: string, params?: unknown[]): Promise<T[]>;
-    get<T>(sql: string, params?: unknown[]): Promise<T | undefined>;
-    close(): Promise<void>;
-}
-
-declare class SQLiteContentManager {
-    protected readonly databasePath: string;
-    protected readonly connection: SQLiteConnection;
-    constructor(databasePath: string);
-    query<T>(sql: string, params?: unknown[]): Promise<T[]>;
-    findById<T extends IDBRecord>(model: string, id: string): Promise<T | undefined>;
-    findAll<T extends IDBRecord>(model: string, conditions?: Partial<T>): Promise<T[]>;
-    getTableCount(): Promise<number>;
-    close(): Promise<void>;
-}
-
-declare class SQLiteRelationManager extends SQLiteContentManager {
-    private readonly translationManager;
-    constructor(databasePath: string);
-    loadRelations(model: string, sourceIds: string[], fieldId: string): Promise<IDBRelation[]>;
-    loadRelatedContent<T extends IDBRecord>(relations: IDBRelation[], locale?: string): Promise<T[]>;
-    getRelationTypes(model: string): Promise<Record<string, 'one-to-one' | 'one-to-many'>>;
-    getRelationFields(model: string): Promise<string[]>;
-}
-
-declare class SQLiteTranslationManager extends SQLiteContentManager {
-    constructor(databasePath: string);
-    hasTranslations(model: string): Promise<boolean>;
-    loadTranslations(model: string, ids: string[], locale?: string): Promise<Record<string, IDBTranslationRecord>>;
-    getLocales(model: string): Promise<string[]>;
-    getMainColumns(model: string): Promise<string[]>;
-    getTranslationColumns(model: string): Promise<string[]>;
-    getAllColumns(model: string): Promise<string[]>;
-}
-
-declare class SQLiteLoader<TData extends IDBRecord = IDBRecord> {
-    private readonly options;
-    readonly contentManager: SQLiteContentManager;
-    readonly relationManager: SQLiteRelationManager;
-    readonly translationManager: SQLiteTranslationManager;
-    private readonly cache?;
-    private readonly modelTTL;
-    private readonly modelConfigs;
-    constructor(options: ISQLiteLoaderOptions);
-    query<T>(sql: string, params?: unknown[]): Promise<T[]>;
-    findById<T extends IDBRecord>(model: string, id: string): Promise<T | undefined>;
-    findAll<T extends IDBRecord>(model: string, conditions?: Partial<T>): Promise<T[]>;
-    private getCacheKey;
-    private getModelTTL;
-    private loadWithTranslations;
-    private getModelFields;
-    private mapSystemFields;
-    private mapRelationFields;
-    private mapTranslationFields;
-    private getFieldType;
-    resolveRelations<TRelation extends IDBRecord>(modelId: string, fieldId: string, data: TData[]): Promise<TRelation[]>;
-    load(model: string): Promise<ISQLiteLoaderResult<TData>>;
-    clearCache(): Promise<void>;
-    refreshCache(modelId: string): Promise<void>;
-    getCacheStats(): Promise<ICacheStats>;
-    close(): Promise<void>;
-}
-
-interface IQueryExecutor<TData, TInclude extends Include = Include, TOptions extends QueryOptions = QueryOptions> {
-    execute: (params: {
-        model: string;
-        filters?: Filter[];
-        includes?: TInclude;
-        sorting?: Sort[];
-        pagination?: Pagination;
-        options?: TOptions;
-    }) => Promise<QueryResult<TData>>;
-}
-declare abstract class BaseQueryExecutor<TData, TInclude extends Include = Include, TOptions extends QueryOptions = QueryOptions> implements IQueryExecutor<TData, TInclude, TOptions> {
-    protected applyStringOperation(value: string, operator: StringOperator, searchValue: string): boolean;
-    protected resolveIncludes(model: string, data: TData[], includes: TInclude, options: TOptions): Promise<TData[]>;
-    protected abstract resolveRelation(model: string, field: string, data: TData[], options: TOptions): Promise<TData[]>;
-    abstract execute(params: {
-        model: string;
-        filters?: Filter[];
-        includes?: TInclude;
-        sorting?: Sort[];
-        pagination?: Pagination;
-        options?: TOptions;
-    }): Promise<QueryResult<TData>>;
-    protected applyFilters(data: TData[], filters?: Filter[]): TData[];
-    protected applySorting(data: TData[], sorting?: Sort[]): TData[];
-    protected applyPagination(data: TData[], limit?: number, offset?: number): TData[];
-    protected compareValues(itemValue: any, operator: string, value: any): boolean;
-    protected getPaginationInfo(pagination: Pagination | undefined, total: number): QueryResult<TData>['pagination'];
-}
-
-declare class SQLiteQueryExecutor<TData extends IDBRecord> extends BaseQueryExecutor<TData, Include, SQLiteOptions> {
-    private loader;
-    constructor(loader: SQLiteLoader<TData>);
-    setLoader(loader: SQLiteLoader<TData>): void;
-    protected resolveRelation(model: string, field: string, data: TData[], options: SQLiteOptions): Promise<TData[]>;
-    execute(params: {
-        model: string;
-        filters?: Filter[];
-        sorting?: Sort[];
-        pagination?: {
-            limit?: number;
-            offset?: number;
-        };
-        options?: SQLiteOptions;
-    }): Promise<QueryResult<TData>>;
-    private buildSQLQuery;
-    private buildSQL;
-    private addTranslationJoin;
-    private buildConditionWithoutParams;
-    private getTotal;
-    protected getPaginationInfo(pagination: {
-        limit?: number;
-        offset?: number;
-    } | undefined, total: number): {
-        limit: number;
-        offset: number;
-        hasMore: boolean;
-    } | undefined;
-    private query;
-    private mainColumns;
-    private translationColumns;
-}
-
-type StringOperator = 'eq' | 'ne' | 'contains' | 'startsWith' | 'endsWith';
-type NumericOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
-type ArrayOperator = 'in' | 'nin';
-type Operator = StringOperator | NumericOperator | ArrayOperator;
-interface Filter {
-    field: string;
-    operator: Operator;
-    value: any;
-}
-interface Sort {
-    field: string;
-    direction: 'asc' | 'desc';
-}
-interface Pagination {
-    limit?: number;
-    offset?: number;
-}
-interface QueryOptions {
-    locale?: string;
-    cache?: boolean;
-    ttl?: number;
-}
-interface QueryResult<TData> {
-    data: TData[];
-    total: number;
-    pagination?: {
-        limit: number;
-        offset: number;
-        hasMore: boolean;
-    };
-}
-interface IncludeOptions {
-    relation: string;
-    locale?: string;
-}
-type Include = string | IncludeOptions | (string | IncludeOptions)[];
-interface IBaseQueryBuilder<TData> {
-    where: (field: keyof TData, operator: Operator, value: any) => this;
-    orderBy: (field: keyof TData, direction?: 'asc' | 'desc') => this;
-    limit: (count: number) => this;
-    offset: (count: number) => this;
-    get: () => Promise<QueryResult<TData>>;
-    first: () => Promise<TData | null>;
-    count: () => Promise<number>;
-    cache: (ttl?: number) => this;
-    noCache: () => this;
-    bypassCache: () => this;
-}
-interface SQLiteOptions {
-    includes?: IncludeOptions[];
-    locale?: string;
-    translations?: boolean;
-}
-type SupportedLocale = string;
-type RelationConfig<T> = {
-    [K in keyof T]: T[K] extends {
-        _relations?: infer R;
-    } ? R : never;
-}[keyof T];
-interface QueryConfig<TModel extends IDBRecord, TLocale extends SupportedLocale = string, TRelations extends Record<string, any> = Record<string, any>> {
-    model: TModel;
-    locale: TLocale;
-    relations: {
-        [K in keyof TRelations]: {
-            relation: K;
-            locale?: TLocale;
-        };
-    };
-}
-interface ISQLiteQuery<TModel extends IDBRecord, TLocale extends SupportedLocale = string, TRelations extends Record<string, any> = Record<string, any>> extends IBaseQueryBuilder<TModel> {
-    include: <K extends keyof TRelations>(relations: K | K[] | {
-        relation: K;
-        locale?: TLocale;
-    } | Array<{
-        relation: K;
-        locale?: TLocale;
-    }>) => this;
-    locale: (code: TLocale) => this;
-    setLoader: (loader: SQLiteLoader<TModel>) => this;
-}
-interface SQLQuery {
-    select: string[];
-    from: string;
-    joins: SQLJoin[];
-    where: Filter[];
-    orderBy: Sort[];
-    parameters: unknown[];
-    pagination?: Pagination;
-    options?: SQLiteOptions;
-}
-interface SQLJoin {
-    type: 'LEFT' | 'INNER';
-    table: string;
-    alias: string;
-    conditions: string[];
-}
-interface JSONOptions extends QueryOptions {
-    defaultLocale?: string;
-}
-interface IJSONQuery<TData extends IBaseJSONRecord> extends IBaseQueryBuilder<TData> {
-    include: (relations: string | string[], reference?: string) => this;
-    locale: (code: string, defaultLocale?: string) => this;
-}
-interface SQLiteQueryConfig<TData extends IDBRecord> {
-    model: string;
-    loader?: SQLiteLoader<TData>;
-    options?: SQLiteOptions;
-}
-interface ISQLiteQueryBuilder<TData extends IDBRecord> {
-    model: string;
-    executor: SQLiteQueryExecutor<TData>;
-    options: SQLiteOptions;
-}
-
-declare class JSONContentManager {
-    protected readonly contentDir: string;
-    protected readonly defaultLocale?: string | undefined;
-    private readonly modelConfigCache;
-    private readonly contentCache;
-    constructor(contentDir: string, defaultLocale?: string | undefined);
-    private getContentCacheKey;
-    loadModelConfig(modelId: string): Promise<IJSONModelConfig>;
-    loadModelContent<T extends IBaseJSONRecord>(modelId: string, locale?: string): Promise<IJSONContentFile<T>>;
-    loadAssets(): Promise<any[]>;
-    getModelLocales(modelId: string): Promise<string[]>;
-    clearCache(): Promise<void>;
-    getCacheStats(): {
-        modelConfigs: number;
-        contents: number;
-    };
-}
-
-declare class JSONLoader<TData extends IBaseJSONRecord> extends JSONContentManager {
-    private readonly options;
-    private readonly relationManager;
-    private readonly cache?;
-    private readonly modelConfigs;
-    constructor(options: IJSONLoaderOptions);
-    private getCacheKey;
-    private getModelTTL;
-    load(modelId: string): Promise<IJSONLoaderResult<TData>>;
-    resolveRelations<TRelation extends IBaseJSONRecord>(modelId: string, relationKey: keyof TData, data: TData[]): Promise<TRelation[]>;
-    clearCache(): Promise<void>;
-    refreshCache(modelId: string): Promise<void>;
-    getCacheStats(): ICacheStats;
-}
-
-declare class QueryFactory {
-    private static loader;
-    static setLoader(loader: SQLiteLoader<IDBRecord> | JSONLoader<IBaseJSONRecord>): void;
-    static createSQLiteBuilder<TData extends IDBRecord>(model: string, loader?: SQLiteLoader<TData>): ISQLiteQuery<TData>;
-    static createJSONBuilder<TData extends IBaseJSONRecord>(model: string, loader?: JSONLoader<TData>): IJSONQuery<TData>;
-    static createBuilder<TData extends IDBRecord | IBaseJSONRecord>(model: string, loader?: SQLiteLoader<TData & IDBRecord> | JSONLoader<TData & IBaseJSONRecord>): TData extends IDBRecord ? ISQLiteQuery<TData & IDBRecord> : IJSONQuery<TData & IBaseJSONRecord>;
-}
-
-declare const loggers: {
-    cache: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    query: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    loader: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    sqlite: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    relation: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    translation: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    executor: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-    default: {
-        debug: (message: string, data?: Record<string, unknown>) => void;
-        info: (message: string, data?: Record<string, unknown>) => void;
-        warn: (message: string, data?: Record<string, unknown>) => void;
-        error: (message: string, data?: Record<string, unknown>) => void;
-    };
-};
-
-declare class MemoryCache {
-    private cache;
-    private options;
-    private stats;
-    constructor(options?: IMemoryCacheOptions);
-    private calculateSize;
-    set<T>(key: string, data: T, ttl?: number): Promise<void>;
-    private findOldestKey;
-    get<T>(key: string): Promise<T | null>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-    private cleanupCache;
-    getStats(): IBaseCacheStats;
-}
-
-interface ContentrainSDKOptions {
-    contentDir?: string;
-    databasePath?: string;
-    cache?: boolean;
-    ttl?: number;
-    maxCacheSize?: number;
-    defaultLocale?: string;
-    modelTTL?: Record<string, number>;
-    logger?: ILogger;
-}
-declare class ContentrainSDK {
-    private static loader;
-    private readonly options;
-    private readonly type;
-    constructor(type: LoaderType, options: ContentrainSDKOptions);
-    query<TData extends IDBRecord | IBaseJSONRecord>(model: string): TData extends IDBRecord ? ISQLiteQuery<TData & IDBRecord> : IJSONQuery<TData & IBaseJSONRecord>;
-    load<TData extends IDBRecord | IBaseJSONRecord>(model: string): Promise<TData>;
-    clearCache(): Promise<void>;
-    refreshCache(model: string): Promise<void>;
-    getCacheStats(): Promise<ICacheStats>;
-}
-
-export { type ArrayOperator, ContentrainSDK, type ContentrainSDKOptions, type ContentrainStatus, type Filter, type IBaseJSONRecord, type IBaseLoader, type IBaseQueryBuilder, type IDBRecord, type IDBRelation, type IDBTranslationRecord, type IJSONContent, type IJSONContentFile, type IJSONContentManager, type IJSONLoaderOptions, type IJSONLoaderResult, type IJSONModelConfig, type IJSONQuery, type IJSONRelationConfig, type IJSONRelationManager, type ILogger, type ISQLiteConnection, type ISQLiteContent, type ISQLiteContentManager, type ISQLiteLoaderOptions, type ISQLiteLoaderResult, type ISQLiteQuery, type ISQLiteQueryBuilder, type ISQLiteRelationManager, type ISQLiteTranslationManager, type Include, type IncludeOptions, JSONLoader, type JSONOptions, type LoaderType, MemoryCache, type NumericOperator, type Operator, type Pagination, type QueryConfig, QueryFactory, type QueryOptions, type QueryResult, type RelationConfig, type RelationType, type SQLJoin, type SQLQuery, SQLiteLoader, type SQLiteOptions, type SQLiteQueryConfig, type Sort, type StringOperator, type SupportedLocale, loggers };
+import { ContentStatus, ContentrainConfig, FieldDef, FieldType, ModelDefinition, ModelKind } from "@contentrain/types";
+
+//#region src/runtime/query.d.ts
+interface RelationMeta {
+  target: string | string[];
+  multi: boolean;
+}
+type RelationResolver = (model: string, id: string, locale: string | null) => Record<string, unknown> | undefined;
+declare class QueryBuilder<T extends object> {
+  private _data;
+  private _locale;
+  private _filters;
+  private _sortField;
+  private _sortOrder;
+  private _limit;
+  private _offset;
+  private _includes;
+  private _relationMeta;
+  private _resolver;
+  private _defaultLocale;
+  constructor(data: Map<string, T[]>, relationMeta?: Record<string, RelationMeta>, resolver?: RelationResolver, defaultLocale?: string);
+  locale(lang: string): this;
+  where<K extends string & keyof T>(field: K, value: T[K]): this;
+  sort<K extends string & keyof T>(field: K, order?: 'asc' | 'desc'): this;
+  limit(n: number): this;
+  offset(n: number): this;
+  include(...fields: string[]): this;
+  all(): T[];
+  first(): T | undefined;
+  private _resolveData;
+  private _resolveIncludes;
+  private _resolveId;
+}
+//#endregion
+//#region src/runtime/singleton.d.ts
+declare class SingletonAccessor<T extends Record<string, unknown>> {
+  private _data;
+  private _locale;
+  private _defaultLocale;
+  private _includes;
+  private _relationMeta;
+  private _resolveEntry?;
+  constructor(data: Map<string, T>, defaultLocale?: string, relationMeta?: Record<string, {
+    target: string | string[];
+    multi: boolean;
+  }>, resolveEntry?: (model: string, id: string, locale: string) => unknown);
+  locale(lang: string): this;
+  include(...fields: string[]): this;
+  get(): T;
+  private _resolveIncludes;
+  private _resolveId;
+}
+//#endregion
+//#region src/runtime/dictionary.d.ts
+declare class DictionaryAccessor {
+  private _data;
+  private _locale;
+  private _defaultLocale;
+  constructor(data: Map<string, Record<string, string>>, defaultLocale?: string);
+  locale(lang: string): this;
+  get(): Record<string, string>;
+  get(key: string): string | undefined;
+  get(key: string, params: Record<string, string | number>): string;
+  private _resolveData;
+}
+//#endregion
+//#region src/runtime/document.d.ts
+declare class DocumentQuery<T extends object> {
+  private _data;
+  private _locale;
+  private _filters;
+  private _includes;
+  private _relationMeta;
+  private _resolver;
+  private _defaultLocale;
+  constructor(data: Map<string, T[]>, relationMeta?: Record<string, RelationMeta>, resolver?: RelationResolver, defaultLocale?: string);
+  locale(lang: string): this;
+  where<K extends string & keyof T>(field: K, value: T[K]): this;
+  include(...fields: string[]): this;
+  bySlug(slug: string): T | undefined;
+  all(): T[];
+  first(): T | undefined;
+  private _resolveData;
+  private _resolveIncludes;
+  private _resolveId;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Factory for framework SDK authors.
+ * Returns the generated client module loaded from .contentrain/client/.
+ *
+ * Usage (Nuxt composable):
+ * ```ts
+ * import { createContentrainClient } from '@contentrain/query'
+ * const client = createContentrainClient()
+ * const posts = client.query('blog-post').locale('en').all()
+ * ```
+ */
+declare function createContentrainClient(projectRoot?: string): Promise<{
+  query: (model: string) => QueryBuilder<Record<string, unknown>>;
+  singleton: (model: string) => SingletonAccessor<Record<string, unknown>>;
+  dictionary: (model: string) => DictionaryAccessor;
+  document: (model: string) => DocumentQuery<Record<string, unknown>>;
+}>;
+//#endregion
+export { type ContentStatus, type ContentrainConfig, DictionaryAccessor, DocumentQuery, type FieldDef, type FieldType, type ModelDefinition, type ModelKind, QueryBuilder, type RelationMeta, type RelationResolver, SingletonAccessor, createContentrainClient, createContentrainClient as default };
+//# sourceMappingURL=index.d.mts.map