import type pgPromise from "pg-promise";
import type { AnyObject, DeleteParams, FieldFilter, InsertParams, Select, UpdateParams } from "prostgles-types";
import type { DB } from "../../Prostgles";
import type { InsertRule, ParsedTableRule, UpdateRule } from "../../PublishParser/PublishParser";
import type TableConfigurator from "../../TableConfig/TableConfig";
import type { TableDefinition } from "../../TableConfig/TableConfig";
import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
import type { TableSchema } from "../DboBuilderTypes";
import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
import type { JoinPaths } from "../ViewHandler/ViewHandler";
import { ViewHandler } from "../ViewHandler/ViewHandler";
import { DataValidator } from "./DataValidator";
export type ValidatedParams = {
    row: AnyObject;
    forcedData?: AnyObject;
    allowedFields?: FieldFilter;
    tableRules?: ParsedTableRule;
    removeDisallowedFields: boolean;
    tableConfigurator: TableConfigurator | undefined;
    tableHandler: TableHandler;
};
export declare class TableHandler extends ViewHandler {
    dataValidator: DataValidator;
    constructor({ db, config, dboBuilder, tableOrViewInfo, tx, joinPaths, }: {
        db: DB;
        tableOrViewInfo: TableSchema;
        dboBuilder: DboBuilder;
        config: TableDefinition<any> | undefined;
        tx?: {
            t: pgPromise.ITask<{}>;
            dbTX: TableHandlers;
        };
        joinPaths?: JoinPaths;
    });
    getFinalDBtx: (localParams: LocalParams | undefined) => TableHandlers | undefined;
    getHooksAndChecks: (command: {
        name: "update";
        rule: undefined | UpdateRule;
    } | {
        name: "insert";
        rule: undefined | InsertRule;
    }) => ({
        readonly commands: Partial<Record<"insert" | "update", 1>>;
        readonly changedFields?: string[];
        readonly validate: (params: import("../../PublishParser/publishTypesAndUtils").ValidateRowArgsCommon<AnyObject, import("../DboBuilderTypes").DBHandlerServer> & {
            localParams: undefined | LocalParams;
        }) => Promise<void>;
        readonly type: "afterEach";
    } | {
        readonly commands: Partial<Record<"insert" | "update", 1>>;
        readonly changedFields?: string[];
        readonly validate: (params: import("../../PublishParser/publishTypesAndUtils").ValidateRowsArgsCommon<AnyObject, import("../DboBuilderTypes").DBHandlerServer> & {
            localParams: undefined | LocalParams;
        }) => Promise<void>;
        readonly type: "afterAll";
    } | {
        readonly type: "postValidate";
        readonly validate: import("../../PublishParser/publishTypesAndUtils").PostValidateRowBasic;
        readonly checkFilter?: undefined;
    } | {
        readonly type: "checkFilter";
        readonly checkFilter: import("prostgles-types").FullFilter<AnyObject, void>;
        readonly validate?: undefined;
    })[];
    shouldWrapInTx: (command: {
        name: "update";
        rule: undefined | UpdateRule;
    } | {
        name: "insert";
        rule: undefined | InsertRule;
    }, localParams: LocalParams | undefined) => boolean;
    getFinalDbo: (localParams: LocalParams | undefined) => TableHandlers;
    parseUpdateRules: (filter: Filter, params?: UpdateParams | undefined, tableRules?: ParsedTableRule | undefined, localParams?: LocalParams | undefined) => Promise<{
        fields: string[];
        validateRow?: import("../../PublishParser/publishTypesAndUtils").ValidateRowBasic;
        finalUpdateFilter: AnyObject;
        forcedData?: AnyObject;
        forcedFilter?: AnyObject;
        returningFields: FieldFilter;
        filterFields?: FieldFilter;
    }>;
    update: (filter: Filter, _newData: AnyObject, params?: UpdateParams | undefined, tableRules?: ParsedTableRule | undefined, localParams?: LocalParams | undefined) => Promise<void | AnyObject>;
    updateBatch: (updates: [Filter, AnyObject][], params?: UpdateParams | undefined, _?: undefined, tableRules?: ParsedTableRule | undefined, localParams?: LocalParams | undefined) => Promise<any>;
    insert(rowOrRows: AnyObject | AnyObject[], param2?: InsertParams, param3_unused?: undefined, tableRules?: ParsedTableRule, _localParams?: LocalParams): Promise<any>;
    insertMany(rows: AnyObject[], param2?: InsertParams, param3_unused?: undefined, tableRules?: ParsedTableRule, _localParams?: LocalParams): Promise<any>;
    prepareReturning: (returning: Select | undefined, allowedFields: string[]) => Promise<SelectItemValidated[]>;
    makeReturnQuery(items?: SelectItemValidated[]): string;
    delete(filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: ParsedTableRule, localParams?: LocalParams): Promise<any>;
    remove(filter: Filter, params?: UpdateParams, param3_unused?: undefined, tableRules?: ParsedTableRule, localParams?: LocalParams): Promise<any>;
    upsert: (filter: Filter, newData: AnyObject, params?: UpdateParams | undefined, table_rules?: ParsedTableRule | undefined, localParams?: LocalParams | undefined) => Promise<any>;
    sync(filter: Filter, params: {
        select?: FieldFilter;
    }, param3_unused: undefined, table_rules: ParsedTableRule, localParams: LocalParams): Promise<{
        channelName: string;
        id_fields: string[];
        synced_field: string;
    }>;
}
export declare const getSelectItemQuery: (items: SelectItemValidated[]) => string;
//# sourceMappingURL=TableHandler.d.ts.map