import type { IDataObject, IExecuteFunctions, INode, INodeExecutionData, INodePropertyOptions, NodeParameterValueType } from 'n8n-workflow';
import { NodeOperationError } from 'n8n-workflow';
import type { ColumnInfo, PgpClient, PgpDatabase, PostgresNodeOptions, QueriesRunner, QueryValues, QueryWithValues, SortRule, WhereClause } from './interfaces';
export declare function isJSON(str: string): boolean;
export declare function evaluateExpression(expression: NodeParameterValueType): string;
export declare function stringToArray(str: NodeParameterValueType | undefined): string[];
export declare function wrapData(data: IDataObject | IDataObject[]): INodeExecutionData[];
export declare function prepareErrorItem(error: IDataObject | NodeOperationError | Error, index: number): INodeExecutionData;
export declare function parsePostgresError(node: INode, error: any, queries: QueryWithValues[], itemIndex?: number): NodeOperationError;
export declare function addWhereClauses(_node: INode, _itemIndex: number, query: string, clauses: WhereClause[], replacements: QueryValues, combineConditions: string): [string, QueryValues];
export declare function addSortRules(query: string, rules: SortRule[], replacements: QueryValues): [string, QueryValues];
export declare function addReturning(query: string, outputColumns: string[], replacements: QueryValues): [string, QueryValues];
export declare function configureQueryRunner(this: IExecuteFunctions, node: INode, continueOnFail: boolean, pgp: PgpClient, db: PgpDatabase): (queries: QueryWithValues[], options: IDataObject) => Promise<INodeExecutionData[] | {
    json: {
        message: string;
        error: {
            type: string | undefined;
            node: INode;
            messages: string[];
            description: string | null | undefined;
            cause?: Error;
            errorResponse?: import("n8n-workflow").JsonObject;
            timestamp: number;
            context: IDataObject;
            lineNumber: number | undefined;
            functionality: import("n8n-workflow").Functionality;
            level: import("@n8n/errors").ErrorLevel;
            tags: NonNullable<import("@sentry/core").Event["tags"]>;
            extra?: import("@sentry/core").Event["extra"];
            packageName?: string;
            name: string;
            message: string;
            stack?: string;
        };
    };
}[]>;
export declare function replaceEmptyStringsByNulls(items: INodeExecutionData[], replace?: boolean): INodeExecutionData[];
export declare function prepareItem(values: IDataObject[]): IDataObject;
export declare function hasJsonDataTypeInSchema(schema: ColumnInfo[]): boolean;
export declare function convertValuesToJsonWithPgp(pgp: PgpClient, schema: ColumnInfo[], values: IDataObject): IDataObject;
export declare function columnFeatureSupport(db: PgpDatabase): Promise<{
    identity_generation: boolean;
    is_generated: boolean;
}>;
export declare function getTableSchema(db: PgpDatabase, schema: string, table: string, options?: {
    getColumnsForResourceMapper?: boolean;
}): Promise<ColumnInfo[]>;
export declare function uniqueColumns(db: PgpDatabase, table: string, schema?: string): Promise<IDataObject[]>;
export declare function getEnums(db: PgpDatabase): Promise<Map<string, string[]>>;
export declare function getEnumValues(enumInfo: Map<string, string[]>, enumName: string): INodePropertyOptions[];
export declare function doesRowExist(db: PgpDatabase, schema: string, table: string, values: string[]): Promise<boolean>;
export declare function checkItemAgainstSchema(node: INode, item: IDataObject, columnsInfo: ColumnInfo[], index: number): IDataObject;
export declare const configureTableSchemaUpdater: (initialSchema: string, initialTable: string) => (db: PgpDatabase, tableSchema: ColumnInfo[], schema: string, table: string) => Promise<ColumnInfo[]>;
/**
 * If postgress column type is array we need to convert it to fornmat that postgres understands, original object data would be modified
 * @param data the object with keys representing column names and values
 * @param schema table schema
 * @param node INode
 * @param itemIndex the index of the current item
 * @returns a new data object with the arrays converted to postgres format
 */
export declare const convertArraysToPostgresFormat: (data: IDataObject, schema: ColumnInfo[], node: INode, itemIndex?: number) => IDataObject;
export declare const isWhereClause: (clause: unknown) => clause is WhereClause;
export declare const getWhereClauses: (ctx: IExecuteFunctions, itemIndex: number) => WhereClause[];
export declare const runQueriesAndHandleErrors: (runQueries: QueriesRunner, queries: QueryWithValues[], nodeOptions: PostgresNodeOptions, errorItemsMap: Map<number, INodeExecutionData>) => Promise<INodeExecutionData[]>;
//# sourceMappingURL=utils.d.ts.map