@contentrain/query 3.2.0 → 4.0.0

package/dist/index.d.mts

@@ -1,154 +1,332 @@
-interface ContentrainConfig {
-    contentDir: string;
-    defaultLocale?: string;
-    models: {
-        [modelId: string]: {
-            localized: boolean;
-            defaultLocale?: string;
-            locales?: string[];
-        };
-    };
+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;
 }
 
-interface BaseContentrainType {
-    ID: string;
-    createdAt: string;
-    updatedAt: string;
-    status: 'draft' | 'changed' | 'publish';
-    scheduled: boolean;
-    _relations?: {
-        [key: string]: BaseContentrainType | BaseContentrainType[];
-    };
+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;
 }
-type ContentrainStatus = 'draft' | 'changed' | 'publish';
-interface ModelMetadata {
-    name: string;
-    modelId: string;
-    localization: boolean;
-    type: 'JSON';
-    createdBy: string;
-    isServerless: boolean;
-}
-interface FieldMetadata {
-    name: string;
-    fieldId: string;
-    modelId: string;
-    componentId: ContentrainComponentId;
-    fieldType: ContentrainFieldType;
-    options: FieldOptions;
-    validations: FieldValidations;
-    system?: boolean;
-    defaultField?: boolean;
-}
-type ContentrainFieldType = 'string' | 'number' | 'boolean' | 'array' | 'date' | 'media' | 'relation';
-type ContentrainComponentId = 'single-line-text' | 'multi-line-text' | 'email' | 'url' | 'slug' | 'color' | 'json' | 'md-editor' | 'rich-text-editor' | 'integer' | 'decimal' | 'rating' | 'percent' | 'phone-number' | 'checkbox' | 'switch' | 'date' | 'date-time' | 'media' | 'one-to-one' | 'one-to-many';
-interface FieldOptions {
-    'title-field'?: {
-        value: boolean;
+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[];
     };
-    'default-value'?: {
-        value: boolean;
-        form: {
-            [key: string]: {
-                value: any;
-            };
-        };
+}
+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;
     };
-    'reference'?: {
-        value: boolean;
-        form: {
-            reference: {
-                value: 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 FieldValidations {
-    'required-field'?: {
-        value: boolean;
-    };
-    'unique-field'?: {
-        value: boolean;
-    };
-    'input-range-field'?: {
-        value: {
-            min: number;
-            max: number;
-        };
-    };
+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[]>;
 }
-type ContentrainLocales = string;
 
-interface ContentLoaderOptions {
-    contentDir: string;
-    defaultLocale?: string;
+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;
-    ttl?: number;
     maxCacheSize?: number;
-    modelTTL?: {
-        [model: string]: number;
+    modelTTL?: number | Record<string, number>;
+    defaultLocale?: string;
+    sorting?: {
+        field: string;
+        direction: 'asc' | 'desc';
     };
 }
-interface ModelConfig {
-    metadata: ModelMetadata;
-    fields: FieldMetadata[];
+interface ISQLiteContent<TData extends IDBRecord> {
+    readonly default: TData[];
+    readonly translations?: Record<string, IDBTranslationRecord[]>;
 }
-interface ContentFile<T extends BaseContentrainType = BaseContentrainType> {
-    model: string;
-    locale?: string;
-    data: T[];
-}
-interface AssetMetadata {
-    path: string;
-    mimetype: string;
-    size: number;
-    alt: string;
-    meta: {
-        user: {
-            name: string;
-            email: string;
-            avatar: string;
+interface ISQLiteLoaderResult<TData extends IDBRecord> {
+    readonly model: {
+        readonly metadata: {
+            readonly modelId: string;
+            readonly name: string;
+            readonly type: 'SQLite';
+            readonly localization: boolean;
+            readonly isServerless: boolean;
         };
-        createdAt: string;
+        readonly fields: Array<{
+            readonly name: string;
+            readonly fieldId: string;
+            readonly type: string;
+        }>;
     };
+    readonly content: ISQLiteContent<TData>;
 }
-interface LoaderResult<T extends BaseContentrainType = BaseContentrainType> {
-    model: ModelConfig;
-    content: {
-        [locale: string]: T[];
-    };
-    assets?: AssetMetadata[];
+interface ISQLiteConnection {
+    query: <T>(sql: string, params?: unknown[]) => Promise<T[]>;
+    get: <T>(sql: string, params?: unknown[]) => Promise<T | undefined>;
+    close: () => void;
 }
-interface RelationConfig {
-    model: string;
-    type: 'one-to-one' | 'one-to-many';
-    foreignKey: string;
+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 CacheStats {
-    hits: number;
-    misses: number;
-    size: number;
-    lastCleanup: number;
+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 CacheEntry<T> {
-    data: T;
-    expireAt: number;
-    size: number;
-    createdAt: number;
+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'];
 }
-interface MemoryCacheOptions {
-    maxSize?: number;
-    defaultTTL?: number;
+
+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<T = any> {
+interface Filter {
     field: string;
     operator: Operator;
-    value: T extends Array<infer U> ? (ArrayOperator extends 'in' | 'nin' ? U[] : U) : T;
+    value: any;
 }
 interface Sort {
     field: string;
@@ -158,19 +336,13 @@ interface Pagination {
     limit?: number;
     offset?: number;
 }
-interface Include {
-    [relation: string]: {
-        fields?: string[];
-        include?: Include;
-    };
-}
 interface QueryOptions {
     locale?: string;
     cache?: boolean;
     ttl?: number;
 }
-interface QueryResult<T> {
-    data: T[];
+interface QueryResult<TData> {
+    data: TData[];
     total: number;
     pagination?: {
         limit: number;
@@ -178,90 +350,186 @@ interface QueryResult<T> {
         hasMore: boolean;
     };
 }
-interface QueryConfig<TFields extends BaseContentrainType, TLocales extends ContentrainLocales = 'en' | 'tr', TRelations extends Record<string, BaseContentrainType> = Record<string, never>> {
-    fields: TFields;
-    locales: TLocales;
-    relations: TRelations;
+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 ContentLoader {
-    private options;
-    private modelConfigs;
-    private relations;
-    private cache;
-    constructor(options: ContentLoaderOptions);
+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(model: string): Promise<void>;
-    getCacheStats(): CacheStats;
-    private loadModelConfig;
-    private loadContentFile;
-    private loadRelations;
-    private getModelLocales;
-    load<T extends BaseContentrainType>(model: string): Promise<LoaderResult<T>>;
-    resolveRelation<T extends BaseContentrainType, R extends BaseContentrainType>(model: string, relationField: keyof T, data: T[], locale?: string): Promise<R[]>;
+    refreshCache(modelId: string): Promise<void>;
+    getCacheStats(): ICacheStats;
 }
 
-declare class QueryExecutor {
-    private loader;
-    constructor(loader: ContentLoader);
-    private applyFilters;
-    private applySorting;
-    private applyPagination;
-    private resolveIncludes;
-    private applyStringOperation;
-    execute<T extends BaseContentrainType>({ model, data, filters, includes, sorting, pagination, options, }: {
-        model: string;
-        data: T[];
-        filters?: Filter[];
-        includes?: Include;
-        sorting?: Sort[];
-        pagination?: {
-            limit?: number;
-            offset?: number;
-        };
-        options?: QueryOptions;
-    }): Promise<QueryResult<T>>;
+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 class ContentrainQueryBuilder<TFields extends BaseContentrainType, TLocales extends ContentrainLocales = 'en' | 'tr', TRelations extends Record<string, BaseContentrainType> = Record<string, never>> {
-    private model;
-    private filters;
-    private includes;
-    private sorting;
-    private pagination;
-    private options;
-    private executor;
-    private loader;
-    constructor(model: string, executor: QueryExecutor, loader: ContentLoader);
-    where<K extends keyof TFields, O extends Operator>(field: K, operator: O, value: O extends 'in' ? TFields[K][] : TFields[K]): this;
-    include<K extends keyof TRelations>(relation: K | K[]): this;
-    orderBy<K extends keyof TFields>(field: K, direction?: 'asc' | 'desc'): this;
-    limit(count: number): this;
-    offset(count: number): this;
-    locale(code: TLocales): this;
-    cache(ttl?: number): this;
-    noCache(): this;
-    bypassCache(): this;
-    toJSON(): {
-        model: string;
-        filters: Filter<any>[];
-        includes: Include;
-        sorting: Sort[];
-        pagination: Pagination;
-        options: QueryOptions;
+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;
     };
-    get(): Promise<QueryResult<TFields>>;
-    first(): Promise<TFields | null>;
-    count(): Promise<number>;
-}
+    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?: MemoryCacheOptions);
+    constructor(options?: IMemoryCacheOptions);
     private calculateSize;
     set<T>(key: string, data: T, ttl?: number): Promise<void>;
     private findOldestKey;
@@ -269,23 +537,29 @@ declare class MemoryCache {
     delete(key: string): Promise<void>;
     clear(): Promise<void>;
     private cleanupCache;
-    getStats(): CacheStats;
+    getStats(): IBaseCacheStats;
 }
 
-declare const logger: {
-    debug: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-};
-
+interface ContentrainSDKOptions {
+    contentDir?: string;
+    databasePath?: string;
+    cache?: boolean;
+    ttl?: number;
+    maxCacheSize?: number;
+    defaultLocale?: string;
+    modelTTL?: Record<string, number>;
+    logger?: ILogger;
+}
 declare class ContentrainSDK {
-    private loader;
-    private executor;
-    constructor(options: ContentLoaderOptions);
-    query<T extends QueryConfig<BaseContentrainType, string, Record<string, BaseContentrainType>>>(model: string): ContentrainQueryBuilder<T['fields'], T['locales'], T['relations']>;
-    load<T extends BaseContentrainType>(model: string): Promise<LoaderResult<T>>;
+    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(): CacheStats;
+    getCacheStats(): Promise<ICacheStats>;
 }
 
-export { type ArrayOperator, type AssetMetadata, type BaseContentrainType, type CacheEntry, type CacheStats, type ContentFile, ContentLoader, type ContentLoaderOptions, type ContentrainComponentId, type ContentrainConfig, type ContentrainFieldType, type ContentrainLocales, ContentrainQueryBuilder, ContentrainSDK, type ContentrainStatus, type FieldMetadata, type FieldOptions, type FieldValidations, type Filter, type Include, type LoaderResult, MemoryCache, type MemoryCacheOptions, type ModelConfig, type ModelMetadata, type NumericOperator, type Operator, type Pagination, type QueryConfig, QueryExecutor, type QueryOptions, type QueryResult, type RelationConfig, type Sort, type StringOperator, logger };
+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 };