import * as clause from "./clause";
export interface Loader<T, V> {
    context?: Context;
    load(key: T): Promise<V>;
    loadMany?(keys: T[]): Promise<(V | null)[]>;
    clearAll(): any;
}
export interface LoaderFactory<T, V> {
    name: string;
    createLoader(context?: Context): Loader<T, V>;
}
export interface ConfigurableLoaderFactory<T, V> extends LoaderFactory<T, V> {
    createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<T, V>;
}
export declare type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause">>;
export interface PrimableLoader<T, V> extends Loader<T, V> {
    prime(d: Data): void;
}
interface cache {
    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
    getCachedRows(options: queryOptions): Data[] | null;
    getCachedRow(options: queryOptions): Data | null;
    primeCache(options: queryOptions, rows: Data[]): void;
    primeCache(options: queryOptions, rows: Data): void;
    clearCache(): void;
}
interface queryOptions {
    fields: string[];
    tableName: string;
    clause: clause.Clause;
    orderby?: string;
}
export interface Context {
    getViewer(): Viewer;
    cache?: cache;
}
export interface Viewer {
    viewerID: ID | null;
    viewer: () => Promise<Ent | null>;
    instanceKey: () => string;
    context?: Context;
}
export interface Ent {
    id: ID;
    viewer: Viewer;
    privacyPolicy: PrivacyPolicy;
    nodeType: string;
}
export declare type Data = {
    [key: string]: any;
};
export interface EntConstructor<T extends Ent> {
    new (viewer: Viewer, data: Data): T;
}
export declare type ID = string | number;
export interface DataOptions {
    tableName: string;
    context?: Context;
}
export interface SelectBaseDataOptions extends DataOptions {
    fields: string[];
}
export interface SelectDataOptions extends SelectBaseDataOptions {
    key: string;
}
export interface QueryableDataOptions extends SelectBaseDataOptions, QueryDataOptions {
}
export interface QueryDataOptions {
    distinct?: boolean;
    clause: clause.Clause;
    orderby?: string;
    groupby?: string;
    limit?: number;
}
export interface LoadRowOptions extends QueryableDataOptions {
}
export interface LoadRowsOptions extends QueryableDataOptions {
}
export interface CreateRowOptions extends DataOptions {
    fields: Data;
    fieldsToLog?: Data;
}
export interface EditRowOptions extends CreateRowOptions {
    key: string;
}
interface LoadableEntOptions<T extends Ent> {
    loaderFactory: LoaderFactory<any, Data | null>;
    ent: EntConstructor<T>;
}
export interface LoadEntOptions<T extends Ent> extends LoadableEntOptions<T>, SelectBaseDataOptions {
}
export interface LoadCustomEntOptions<T extends Ent> extends SelectBaseDataOptions {
    ent: EntConstructor<T>;
}
export interface EditEntOptions<T extends Ent> extends LoadableEntOptions<T>, EditRowOptions {
}
declare enum privacyResult {
    Allow = 200,
    Deny = 401,
    Skip = 307
}
export interface PrivacyResult {
    result: privacyResult;
    error?: PrivacyError;
}
export interface PrivacyError extends Error {
    privacyPolicy: PrivacyPolicy;
    ent?: Ent;
}
export declare function Allow(): PrivacyResult;
export declare function Skip(): PrivacyResult;
export declare function Deny(): PrivacyResult;
export declare function DenyWithReason(e: PrivacyError): PrivacyResult;
export interface PrivacyPolicyRule {
    apply(v: Viewer, ent?: Ent): Promise<PrivacyResult>;
}
export interface PrivacyPolicy {
    rules: PrivacyPolicyRule[];
}
export {};