import { Queryer, SyncQueryer } from "./db";
import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions } from "./base";
import { Executor } from "../action";
import * as clause from "./clause";
import { Builder } from "../action";
import DataLoader from "dataloader";
export declare function loadEnt<T extends Ent>(viewer: Viewer, id: ID, options: LoadEntOptions<T>): Promise<T | null>;
export declare function loadEntViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T | null>;
export declare function loadEntX<T extends Ent>(viewer: Viewer, id: ID, options: LoadEntOptions<T>): Promise<T>;
export declare function loadEntXViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T>;
export declare function loadEntFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T | null>;
export declare function loadEntXFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T>;
export declare function loadEnts<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<T[]>;
export declare function loadEntsFromClause<T extends Ent>(viewer: Viewer, clause: clause.Clause, options: LoadEntOptions<T>): Promise<Map<ID, T>>;
export declare function loadCustomEnts<T extends Ent>(viewer: Viewer, options: LoadCustomEntOptions<T>, query: CustomQuery): Promise<T[]>;
interface rawQueryOptions {
    query: string;
    values?: any[];
    logValues?: any[];
}
export declare type CustomQuery = string | rawQueryOptions | clause.Clause | QueryDataOptions;
export declare function loadCustomData(options: SelectBaseDataOptions, query: CustomQuery, context: Context | undefined): Promise<Data[]>;
export declare function loadDerivedEnt<T extends Ent>(viewer: Viewer, data: Data, loader: new (viewer: Viewer, data: Data) => T): Promise<T | null>;
export declare function loadDerivedEntX<T extends Ent>(viewer: Viewer, data: Data, loader: new (viewer: Viewer, data: Data) => T): Promise<T>;
export declare function applyPrivacyPolicyForEnt<T extends Ent>(viewer: Viewer, ent: T | null): Promise<T | null>;
export declare function applyPrivacyPolicyForEntX<T extends Ent>(viewer: Viewer, ent: T): Promise<T>;
export declare function loadRowX(options: LoadRowOptions): Promise<Data>;
export declare function loadRow(options: LoadRowOptions): Promise<Data | null>;
export declare function performRawQuery(query: string, values: any[], logValues?: any[]): Promise<Data[]>;
export declare function loadRows(options: LoadRowsOptions): Promise<Data[]>;
export declare function buildQuery(options: QueryableDataOptions): string;
interface GroupQueryOptions {
    tableName: string;
    clause?: clause.Clause;
    groupColumn: string;
    fields: string[];
    values: any[];
    orderby?: string;
    limit: number;
}
export declare function buildGroupQuery(options: GroupQueryOptions): [string, clause.Clause];
export interface DataOperation {
    preFetch?(queryer: Queryer, context?: Context): Promise<void>;
    performWriteSync(queryer: SyncQueryer, context?: Context): void;
    performWrite(queryer: Queryer, context?: Context): Promise<void>;
    returnedEntRow?(): Data | null;
    resolve?(executor: Executor): void;
    postFetch?(queryer: Queryer, context?: Context): Promise<void>;
}
export interface EditNodeOptions extends EditRowOptions {
    fieldsToResolve: string[];
}
export declare class EditNodeOperation implements DataOperation {
    options: EditNodeOptions;
    private existingEnt;
    row: Data | null;
    constructor(options: EditNodeOptions, existingEnt?: Ent | null);
    resolve<T extends Ent>(executor: Executor): void;
    performWrite(queryer: Queryer, context?: Context): Promise<void>;
    reloadRow(queryer: SyncQueryer, id: ID, options: EditNodeOptions): void;
    performWriteSync(queryer: SyncQueryer, context?: Context): void;
    returnedEntRow(): Data | null;
}
export declare class EdgeOperation implements DataOperation {
    edgeInput: AssocEdgeInput;
    private options;
    private edgeData;
    private constructor();
    preFetch(queryer: Queryer, context?: Context): Promise<void>;
    performWrite(queryer: Queryer, context?: Context): Promise<void>;
    performWriteSync(queryer: SyncQueryer, context?: Context): void;
    private getDeleteRowParams;
    private performDeleteWrite;
    private performDeleteWriteSync;
    private getInsertRowParams;
    private performInsertWrite;
    private performInsertWriteSync;
    private resolveImpl;
    resolve(executor: Executor): void;
    symmetricEdge(): EdgeOperation;
    inverseEdge(edgeData: AssocEdgeData): EdgeOperation;
    private static resolveIDs;
    private static isBuilder;
    private static resolveData;
    static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
    static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID): EdgeOperation;
    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID): EdgeOperation;
}
export declare function buildInsertQuery(options: CreateRowOptions, suffix?: string): [string, string[], string[]];
export declare function createRow(queryer: Queryer, options: CreateRowOptions, suffix: string): Promise<Data | null>;
export declare function createRowSync(queryer: SyncQueryer, options: CreateRowOptions, suffix: string): Data | null;
export declare function buildUpdateQuery(options: EditRowOptions, id: ID, suffix?: string): [string, any[], any[]];
export declare function editRow(queryer: Queryer, options: EditRowOptions, id: ID, suffix?: string): Promise<Data | null>;
export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, id: ID, suffix?: string): Data | null;
export declare function deleteRows(queryer: Queryer, options: DataOptions, cls: clause.Clause): Promise<void>;
export declare function deleteRowsSync(queryer: SyncQueryer, options: DataOptions, cls: clause.Clause): void;
export declare class DeleteNodeOperation implements DataOperation {
    private id;
    private options;
    constructor(id: ID, options: DataOptions);
    performWrite(queryer: Queryer, context?: Context): Promise<void>;
    performWriteSync(queryer: SyncQueryer, context?: Context): void;
}
export declare class AssocEdge {
    id1: ID;
    id1Type: string;
    edgeType: string;
    id2: ID;
    id2Type: string;
    time: Date;
    data?: string | null;
    constructor(data: Data);
    getCursor(): string;
}
interface cursorOptions {
    row: Data;
    col: string;
    cursorKey?: string;
    conv?: (any: any) => any;
}
export declare function getCursor(opts: cursorOptions): string;
export interface AssocEdgeInputOptions {
    time?: Date;
    data?: string | Builder<Ent>;
}
export interface AssocEdgeInput extends AssocEdgeInputOptions {
    id1: ID;
    id1Type: string;
    edgeType: string;
    id2: ID;
    id2Type: string;
}
export declare class AssocEdgeData {
    edgeType: string;
    edgeName: string;
    symmetricEdge: boolean;
    inverseEdgeType?: string;
    edgeTable: string;
    constructor(data: Data);
}
export declare const assocEdgeLoader: DataLoader<any, any, any>;
export declare function loadEdgeData(edgeType: string): Promise<AssocEdgeData | null>;
export declare function loadEdgeDatas(...edgeTypes: string[]): Promise<Map<string, AssocEdgeData>>;
export interface AssocEdgeConstructor<T extends AssocEdge> {
    new (row: Data): T;
}
interface loadEdgesOptions {
    id1: ID;
    edgeType: string;
    context?: Context;
    queryOptions?: EdgeQueryableDataOptions;
}
interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
    ctr: AssocEdgeConstructor<T>;
}
export declare const DefaultLimit = 1000;
export declare function defaultEdgeQueryOptions(id1: ID, edgeType: string): EdgeQueryableDataOptions;
export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;
export declare function loadUniqueEdge(options: loadEdgesOptions): Promise<AssocEdge | null>;
export declare function loadUniqueNode<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T | null>;
export declare function loadRawEdgeCountX(options: loadEdgesOptions): Promise<number>;
interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptions<T> {
    id2: ID;
}
export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
export declare function applyPrivacyPolicyForRow<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data | null): Promise<T | null>;
export declare function applyPrivacyPolicyForRowX<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data): Promise<T>;
export declare function applyPrivacyPolicyForRows<T extends Ent>(viewer: Viewer, rows: Data[], options: LoadEntOptions<T>): Promise<Map<ID, T>>;
export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
export {};