export declare type ComparisonOperators = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'like' | 'not_like' | 'in' | 'not_in' | 'includes' | 'excludes';
export declare type LogicalOperators = 'not' | 'and' | 'or' | 'true';
export declare type FieldResultType = 'any' | 'number' | 'string' | 'boolean' | 'date' | 'datetime';
export interface PreparedDateValue {
    type: 'date';
    value: string;
}
export interface PreparedDateTimeValue {
    type: 'datetime';
    value: string;
}
export interface PreparedParameterizedValue {
    type: 'parameter';
    name: string;
}
export declare type PreparedPrimitiveAtomValue = number | string | boolean | null;
export declare type PreparedAtomValue = PreparedPrimitiveAtomValue | PreparedDateValue | PreparedDateTimeValue;
export declare type PreparedValue = PreparedAtomValue | PreparedParameterizedValue | Array<PreparedAtomValue | PreparedParameterizedValue>;
export interface PreparedFieldBase {
    aliasName?: string | null;
}
export interface PreparedFieldBaseForFnCall {
    aliasName: string;
}
export interface PreparedField extends PreparedFieldBase {
    type: 'field';
    name: string[];
}
export interface PreparedFnCall extends PreparedFieldBaseForFnCall {
    type: 'fncall';
    fn: string;
    args: Array<Omit<PreparedField, 'aliasName'> | PreparedAtomValue | PreparedParameterizedValue | PreparedFnCall>;
}
export interface PreparedSubQuery extends PreparedFieldBase {
    type: 'subquery';
    query: PreparedQuery;
}
export declare type PreparedFieldListItem = PreparedField | PreparedFnCall | PreparedSubQuery;
export interface ParsedResolverBase {
    name: string[];
    aliasName: string | null;
    resolver?: QueryResolverFn;
    resolverName?: string;
}
export interface PreparedResolverCompiledProps {
    queryFields?: Set<string>;
    queryFieldsMap?: Map<string, PreparedFieldListItem>;
    condFields?: Set<string>;
    condAliasFields?: Set<string>;
    havingCondFields?: Set<string>;
    fieldAliasNames?: Set<string>;
    sortFieldNames?: Set<string>;
    relationshipIdFields?: Set<string>;
}
export declare type ParsedResolver = ParsedResolverBase & PreparedResolverCompiledProps;
export declare type PreparedResolver = ParsedResolverBase & Required<PreparedResolverCompiledProps>;
export declare type PreparedConditionOperand = PreparedCondition | PreparedValue | PreparedFieldListItem;
export interface PreparedCondition {
    type: 'condition';
    op: LogicalOperators | ComparisonOperators;
    operands: Array<PreparedConditionOperand>;
}
export interface PreparedOrderByField {
    name: string[];
    direction: 'asc' | 'desc';
    nulls: 'first' | 'last';
}
export interface ParsedQueryBase {
    select: PreparedFieldListItem[];
    where?: PreparedCondition[];
    having?: PreparedCondition[];
    groupBy?: string[];
    orderBy?: PreparedOrderByField[];
    limit?: number | PreparedParameterizedValue | null;
    offset?: number | PreparedParameterizedValue | null;
    for?: string[];
}
export interface PreparedQueryCompiledProps {
    whereSubQueries?: PreparedSubQuery[];
    havingSubQueries?: PreparedSubQuery[];
    selectSubQueries?: PreparedSubQuery[];
}
export declare type ParsedQuery = ParsedQueryBase & {
    from: ParsedResolver[];
} & PreparedQueryCompiledProps;
export declare type PreparedQuery = ParsedQueryBase & {
    from: PreparedResolver[];
} & PreparedQueryCompiledProps;
export interface ExecutionPlan {
    query: PreparedQuery;
    children: ExecutionPlan[];
}
export interface ExecutionPlanRoot {
    children: ExecutionPlan[];
    generations: Array<Promise<any>[]>;
}
export declare const enum ResolverTreeDirection {
    DetailsToMaster = 1,
    MasterToDetail = 2
}
export interface ResolverTreeNode {
    fieldOrRelName: string;
    resolverName: string;
    direction: ResolverTreeDirection.DetailsToMaster | ResolverTreeDirection.MasterToDetail;
    children: ResolverTreeNode[];
}
export interface ResolverCapabilities {
    filtering: boolean;
    sorting: boolean;
    limit: boolean;
    offset: boolean;
}
export declare type QueryParams = {
    [paramNames: string]: PreparedAtomValue | Array<PreparedAtomValue>;
};
export interface IQuery {
    execute<R>(params?: QueryParams): Promise<R[]>;
}
export interface ResolverContext {
    functions: QueryFuncInfo[];
    query?: PreparedQuery;
    params?: QueryParams;
    graphPath: string[];
    resolverName: string;
    parentResolverName?: string;
    parentType?: 'master' | // Accessed by `Select (Select childField From details) From Master`
    'detail';
    parent?: any;
    foreignIdField?: string;
    masterIdField?: string;
    detailIdField?: string;
    parentRecords?: any[];
    conditions?: PreparedCondition[];
    resolverCapabilities: ResolverCapabilities;
    resolverData: any;
    transactionData: any;
    transactionOptions: any | undefined;
}
export interface ResolverEvent extends Partial<ResolverContext> {
    resolverData: any;
    transactionData: any;
    transactionOptions: any | undefined;
}
export declare type QueryResolverFn = (fields: string[], // NOTE: Relationship fields are not included.
conditions: PreparedCondition[], limit: number | null, offset: number | null, ctx: ResolverContext) => Promise<any[]>;
export declare type InsertResolverFn = (records: any[], ctx: ResolverContext) => Promise<any[]>;
export declare type UpdateResolverFn = (records: any[], ctx: ResolverContext) => Promise<any[]>;
export declare type RemoveResolverFn = (records: any[], ctx: ResolverContext) => Promise<void>;
export declare type AggregateFunction = (ctx: Omit<ResolverContext, 'resolverCapabilities'>, args: Array<PreparedAtomValue | PreparedAtomValue[]>, records: any[]) => any;
export declare type ScalarFunction = (ctx: Omit<ResolverContext, 'resolverCapabilities'>, args: PreparedAtomValue[], record: any) => any;
export declare type ImmediateScalarFunction = (ctx: Omit<ResolverContext, 'resolverCapabilities'>, args: PreparedAtomValue[]) => any;
export interface AggregateQueryFuncInfo {
    type: 'aggregate';
    name: string;
    fn: AggregateFunction;
}
export interface ScalarQueryFuncInfo {
    type: 'scalar';
    name: string;
    fn: ScalarFunction;
}
export interface ImmediateScalarQueryFuncInfo {
    type: 'immediate-scalar';
    name: string;
    fn: ImmediateScalarFunction;
}
export declare type QueryFuncInfo = AggregateQueryFuncInfo | ScalarQueryFuncInfo | ImmediateScalarQueryFuncInfo;
export interface QueryBuilderInfoRulesSection {
    idFieldName?: (resolverName: string) => string;
    foreignIdFieldName?: (masterResolverName: string | undefined) => string | undefined;
}
export interface QueryBuilderInfoResolversSection {
    query: {
        [resolverNames: string]: QueryResolverFn;
    };
    insert?: {
        [resolverNames: string]: InsertResolverFn;
    };
    update?: {
        [resolverNames: string]: UpdateResolverFn;
    };
    remove?: {
        [resolverNames: string]: RemoveResolverFn;
    };
}
export interface QueryBuilderInfo {
    /** Additional (user defined) SOQL functions */
    functions?: QueryFuncInfo[];
    rules?: QueryBuilderInfoRulesSection;
    /** */
    events?: {
        beginTransaction?: (evt: ResolverEvent) => Promise<void>;
        endTransaction?: (evt: ResolverEvent, err: Error | null) => Promise<void>;
        beginExecute?: (evt: ResolverEvent) => Promise<void>;
        endExecute?: (evt: ResolverEvent, err: Error | null) => Promise<void>;
        beforeMasterSubQueries?: (evt: ResolverEvent) => Promise<void>;
        afterMasterSubQueries?: (evt: ResolverEvent) => Promise<void>;
        beforeDetailSubQueries?: (evt: ResolverEvent) => Promise<void>;
        afterDetailSubQueries?: (evt: ResolverEvent) => Promise<void>;
    };
    /** */
    resolvers: QueryBuilderInfoResolversSection;
    /** */
    relationships?: {
        /**
         * detailResolverName
         * e.g.: Contact: { account: 'Account' }
         *       Contact: { account: { resolver: 'Account', id: 'accountId' } }
         *
         * NOTE: 'Account' is `masterResolverName`.
         *       'account' is `masterObjectFieldName`.
         *       'accountId' is `masterIdName`. (foreign key field name)
         *       `Contact (resolver) -> account (field name)` direction is `Detail to Master`.
         *
         * masterResolverName
         * e.g.: Account: { contacts: ['Contact'] }
         *       Account: { contacts: ['Contact', 'account'] }
         *
         * NOTE: 'contacts' is details relationship name.
         *       'Contact' is `detailResolverName` and 'account' is Contact's `masterObjectFieldName`.
         *       Default masterObjectFieldName is `MasterResolverName`.
         *       `Account (resolver) -> contacts (relationship name)` direction is `Master to Details`.
         */
        [detailOrMasterResolverNames: string]: {
            [fieldOrRelNames: string]: string | {
                resolver: string;
                id: string;
            } | [
                string,
                string?
            ];
        };
    };
}
export declare type QueryBuilderInfoInternal = Required<QueryBuilderInfo> & {
    rules: Required<QueryBuilderInfoRulesSection>;
    resolvers: Required<QueryBuilderInfoResolversSection>;
};
export interface SubscriberParams {
    on: 'insert' | 'update' | 'remove';
    resolver: string;
    id: any | null;
}
export declare type Subscriber = (params: SubscriberParams) => void;
export interface SqlDialect {
    fieldName: (name: string) => string;
    escapeString: (s: string) => string;
}