import type { EntitySubscribeOptions, TableSubscribeOptions, Subscription } from './core/notifications';
import type { OrderByExpression } from './core/order-by';
import type { SelectFieldMap } from './core/pod-session';
import type { PublicQueryCondition, PublicWhereObject } from './core/query-conditions';
import { PodTable, SolidSchema, type InferInsertData, type InferTableData, type InstantiateTableOptions, type PodColumnBase } from './core/schema';
import type { DataLocation, DiscoverOptions, LocationToTableOptions } from './core/discovery';
import type { FederatedError } from './core/federated';
import { type SolidAuthSession, type SolidDatabase, type SolidDrizzleConfig } from './driver';
type CollectionWhere = PublicWhereObject | PublicQueryCondition;
type CollectionOrderBy = PodColumnBase | string | OrderByExpression | 'asc' | 'desc';
export interface PodCollectionQueryOptions<TTable extends PodTable<any> = PodTable<any>> {
    fields?: SelectFieldMap;
    where?: CollectionWhere;
    limit?: number;
    offset?: number;
    orderBy?: CollectionOrderBy[];
}
export declare class PodEntity<TTable extends PodTable<any>, TSchema extends Record<string, unknown> = Record<string, never>> {
    private readonly db;
    readonly table: TTable;
    readonly iri: string;
    constructor(db: SolidDatabase<TSchema>, table: TTable, iri: string);
    get documentUrl(): string;
    get fragment(): string | null;
    get(): Promise<InferTableData<TTable> | null>;
    read(): Promise<InferTableData<TTable> | null>;
    update(data: Partial<Omit<InferTableData<TTable>, '@id' | 'id'>>): Promise<InferTableData<TTable> | null>;
    delete(): Promise<boolean>;
    subscribe(options: EntitySubscribeOptions<InferTableData<TTable>>): Promise<() => void>;
}
export declare class PodCollection<TTable extends PodTable<any>, TSchema extends Record<string, unknown> = Record<string, never>> {
    private readonly db;
    readonly table: TTable;
    constructor(db: SolidDatabase<TSchema>, table: TTable);
    byIri(iri: string): PodEntity<TTable, TSchema>;
    entity(iri: string): PodEntity<TTable, TSchema>;
    iriFor(record: InferInsertData<TTable>): string;
    select(fields?: SelectFieldMap): import("./core/pod-session").SelectQueryBuilder<TTable>;
    list(options?: PodCollectionQueryOptions<TTable>): Promise<InferTableData<TTable>[]>;
    first(options?: PodCollectionQueryOptions<TTable>): Promise<InferTableData<TTable> | null>;
    create(record: InferInsertData<TTable>): Promise<InferTableData<TTable> | null>;
    create(records: InferInsertData<TTable>[]): Promise<Array<InferTableData<TTable>>>;
    createMany(records: InferInsertData<TTable>[]): Promise<Array<InferTableData<TTable>>>;
    subscribe(options: TableSubscribeOptions): Promise<Subscription>;
}
export declare class PodClient<TSchema extends Record<string, unknown> = Record<string, never>> {
    private readonly db;
    constructor(db: SolidDatabase<TSchema>);
    asDrizzle(): SolidDatabase<TSchema>;
    get query(): { [K in keyof TSchema as TSchema[K] extends PodTable<any> ? K : never]: TSchema[K] extends PodTable<any> ? {
        findMany<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(options?: {
            where?: PublicWhereObject | PublicQueryCondition;
            columns?: SelectFieldMap;
            limit?: number;
            offset?: number;
            orderBy?: {
                column: PodColumnBase | string | OrderByExpression;
                direction?: "asc" | "desc";
            }[] | {
                column: PodColumnBase | string | OrderByExpression;
                direction?: "asc" | "desc";
            };
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T[]>;
        findFirst<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(options?: {
            where?: PublicWhereObject | PublicQueryCondition;
            columns?: SelectFieldMap;
            limit?: number;
            offset?: number;
            orderBy?: {
                column: PodColumnBase | string | OrderByExpression;
                direction?: "asc" | "desc";
            }[] | {
                column: PodColumnBase | string | OrderByExpression;
                direction?: "asc" | "desc";
            };
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T | null>;
        find<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(target: string | {
            [x: string]: unknown;
        }, options?: {
            columns?: SelectFieldMap;
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T | null>;
        findById<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(id: string, options?: {
            columns?: SelectFieldMap;
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T | null>;
        findByResource<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(target: string | {
            [x: string]: unknown;
        }, options?: {
            columns?: SelectFieldMap;
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T | null>;
        findByLocator<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(locator: {
            [x: string]: unknown;
        }, options?: {
            columns?: SelectFieldMap;
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T | null>;
        findByIri<T = { [K_3 in keyof TSchema[K]["columns"]]: import("./core/schema").InferColumnType<TSchema[K]["columns"][K_3]>; } extends infer T_1 ? { [K_2 in keyof T_1]: T_1[K_2]; } : never>(iri: string, options?: {
            columns?: SelectFieldMap;
            with?: Record<string, boolean | {
                table?: PodTable<any>;
            }>;
        }): Promise<T | null>;
        count(options?: {
            where?: PublicWhereObject | PublicQueryCondition;
        }): Promise<number>;
    } : never; };
    bind<TColumns extends Record<string, PodColumnBase<any, any, any, any>>>(schema: SolidSchema<TColumns>, options: InstantiateTableOptions): PodTable<TColumns>;
    locationToTable(location: DataLocation, options?: LocationToTableOptions): Promise<PodTable<any>>;
    discoverTablesFor(rdfClass: string, options?: DiscoverOptions, tableOptions?: LocationToTableOptions): Promise<PodTable<any>[]>;
    collection<TTable extends PodTable<any>>(table: TTable): PodCollection<TTable, TSchema>;
    entity<TTable extends PodTable<any>>(table: TTable, iri: string): PodEntity<TTable, TSchema>;
    init<TTable extends PodTable<any>>(...tables: Array<TTable | TTable[]>): Promise<void>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    sparql(query: string): Promise<unknown[]>;
    batch<TOperations extends readonly unknown[]>(operations: TOperations): Promise<{
        [K in keyof TOperations]: Awaited<TOperations[K]>;
    }>;
    getLastFederatedErrors(): FederatedError[];
    get discovery(): import("./core/discovery").DataDiscovery;
}
export declare function pod<TSchema extends Record<string, unknown> = Record<string, never>>(session: SolidAuthSession, config?: SolidDrizzleConfig<TSchema>): PodClient<TSchema>;
export {};
//# sourceMappingURL=pod.d.ts.map