import type { InferInsertData, InferTableData, InferUpdateData, PodTable } from './schema';
import { type QueryCondition } from './query-conditions';
import type { SolidDatabase } from '../driver';
type RepositoryTable = PodTable<any>;
export type AnyPodTable = RepositoryTable;
export type AnyPodResource = RepositoryTable;
export interface PodExecutableQuery<TRow = unknown> {
    where(condition: unknown): PodExecutableQuery<TRow>;
    whereByIri?(iri: string | string[]): PodExecutableQuery<TRow>;
    orderBy(...args: unknown[]): PodExecutableQuery<TRow>;
    execute(): Promise<TRow[]>;
}
export interface PodInsertQuery {
    values(values: unknown): {
        execute(): Promise<unknown[]>;
    };
}
export interface PodUpdateQuery {
    set(values: unknown): PodMutationQuery;
}
export interface PodMutationQuery {
    where(condition: unknown): PodMutationQuery;
    whereByIri?(iri: string): PodMutationQuery;
    execute(): Promise<unknown[]>;
}
export declare function initSolidTables(db: Pick<SolidDatabase, 'init'>, tables: AnyPodTable[]): Promise<void>;
export declare const initSolidResources: typeof initSolidTables;
export interface RepositoryCacheOptions {
    staleTime?: number;
    gcTime?: number;
}
export type RepositoryScope = 'list' | 'detail' | string;
export interface RepositoryInvalidations {
    create?: RepositoryScope[];
    update?: RepositoryScope[];
    remove?: RepositoryScope[];
}
export interface RepositoryFilterContext<TTable extends RepositoryTable, Filters> {
    table: TTable;
    filters?: Filters;
}
export interface PodRepositoryDescriptor<TTable extends RepositoryTable, Row extends Record<string, unknown> = InferTableData<TTable>, Insert = InferInsertData<TTable>, Update = InferUpdateData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>> {
    namespace: string;
    resourcePath: string;
    searchableFields?: (keyof Row & string)[];
    defaultSort?: {
        field: keyof Row & string;
        direction: 'asc' | 'desc';
    };
    cache?: RepositoryCacheOptions;
    invalidations: RepositoryInvalidations;
    list: (db: SolidDatabase, filters?: Filters) => Promise<Row[]>;
    detail: (db: SolidDatabase, id: string) => Promise<Row | null>;
    create?: (db: SolidDatabase, input: Insert) => Promise<Row>;
    update?: (db: SolidDatabase, id: string, input: Update) => Promise<Row>;
    remove?: (db: SolidDatabase, id: string) => Promise<{
        id: string;
    }>;
}
export interface PodRepositoryOptions<TTable extends RepositoryTable, Row extends Record<string, unknown> = InferTableData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>> {
    namespace: string;
    table: TTable;
    searchableFields?: (keyof Row & string)[];
    searchAccessor?: (filters?: Filters) => string | undefined;
    defaultSort?: {
        field: keyof Row & string;
        direction: 'asc' | 'desc';
    };
    cache?: RepositoryCacheOptions;
    invalidations?: Partial<RepositoryInvalidations>;
    transform?: (row: Row) => Row;
    filter?: (context: RepositoryFilterContext<TTable, Filters>) => QueryCondition | undefined;
    disableMutations?: Partial<Record<'create' | 'update' | 'remove', boolean>>;
}
export declare function createRepositoryDescriptor<TTable extends RepositoryTable, Row extends Record<string, unknown> = InferTableData<TTable>, Insert = InferInsertData<TTable>, Update = InferUpdateData<TTable>, Filters extends Record<string, unknown> = Record<string, unknown>>(options: PodRepositoryOptions<TTable, Row, Filters>): PodRepositoryDescriptor<TTable, Row, Insert, Update, Filters>;
export declare const definePodRepository: typeof createRepositoryDescriptor;
export {};
//# sourceMappingURL=repository.d.ts.map