import { Types, Config } from '@genesislcap/expression-builder';
declare module '@genesislcap/expression-builder' {
    namespace Types {
        type RuleConfig = Pick<Types.Config, 'fields' | 'maxNesting' | 'partialRuleValidationWarning'> & {
            model?: RuleExpression.Expression['PredicateExpression'];
        };
        type ValueConfig = Pick<Types.Config, 'fields' | 'maxNesting' | 'partialRuleValidationWarning'> & {
            model?: RuleExpression.Expression['BinaryExpression'] | RuleExpression.Expression['MethodExpression'];
        };
    }
}
export { Types as ExpressionBuilderTypes, Config as ExpressionBuilderConfig };
export declare const ExpressionBuilderCore: {
    template: import("@microsoft/fast-element").ViewTemplate<import("@genesislcap/expression-builder").ExpressionBuilder, any>;
    styles: import("@microsoft/fast-element").ElementStyles;
};
/**
 * Based on the RuleExpression config in Kotlin
 */
export declare namespace RuleExpression {
    type BooleanValue = {
        VALUE: boolean;
        TYPE: 'BOOLEAN';
    };
    type Field = {
        NAME: string;
        TYPE: 'FIELD';
    };
    type NumericValue = {
        VALUE: string;
        TYPE: 'NUMBER';
    };
    type StringValue = {
        VALUE: string;
        TYPE: 'STRING';
    };
    type PlaceHolder = {
        KEY: string;
        TYPE: 'PLACEHOLDER';
    };
    type NullValue = {
        TYPE: 'NULL';
    };
    type RuleExpression = {
        CONDITIONS: Condition[];
    };
    type ResultExpression = {
        ASSIGNMENTS: Assignment[];
    };
    type Condition = {
        LEFT: Expression['SingleExpression'];
        OPERATION: Operation;
        RIGHT: Expression[keyof Expression];
    };
    type Assignment = {
        FIELD: Field;
        VALUE: Expression[keyof Expression];
    };
    type Expression = {
        SingleExpression: BooleanValue | Field | NumericValue | StringValue | PlaceHolder | NullValue;
        BinaryExpression: {
            LEFT: Expression[keyof Expression];
            OPERATION: Operation;
            RIGHT: Expression[keyof Expression];
            TYPE: 'BINARY_EXPRESSION';
        };
        MethodExpression: {
            METHOD: MethodCall;
            PARAMETERS: Expression['SingleExpression'][];
            TYPE: 'METHOD_EXPRESSION';
        };
        PredicateExpression: {
            TYPE: 'PREDICATE_EXPRESSION';
            OPERATION: LogicalOperation;
            EXPRESSIONS: Expression[keyof Expression][];
        };
    };
    const methodCall: {
        readonly CONTAINS_IGNORE_CASE: "CONTAINS_IGNORE_CASE";
        readonly CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE: "CONTAINS_WORDS_STARTING_WITH_IGNORE_CASE";
        readonly IS_NULL_OR_BLANK: "IS_NULL_OR_BLANK";
        readonly NOT_NULL_OR_BLANK: "NOT_NULL_OR_BLANK";
        readonly TRIM: "TRIM";
        readonly LONG_TO_DATE: "LONG_TO_DATE";
        readonly LONG_TO_DATE_TIME: "LONG_TO_DATE_TIME";
        readonly DATE_TIME_IS_IN_RANGE: "DATE_TIME_IS_IN_RANGE";
    };
    type MethodCall = keyof typeof methodCall;
    const logicalOperations: {
        readonly AND: "AND";
        readonly OR: "OR";
    };
    const operations: {
        readonly GREATER_THAN: "GREATER_THAN";
        readonly LESS_THAN: "LESS_THAN";
        readonly GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
        readonly LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
        readonly EQUALS: "EQUALS";
        readonly NOT_EQUALS: "NOT_EQUALS";
        readonly PLUS: "PLUS";
        readonly MINUS: "MINUS";
        readonly MULTIPLY: "MULTIPLY";
        readonly DIVIDE: "DIVIDE";
        readonly BITWISE_AND: "BITWISE_AND";
        readonly BITWISE_OR: "BITWISE_OR";
        readonly ASSIGNMENT: "ASSIGNMENT";
        readonly IS_CURRENT: "IS_CURRENT";
        readonly IS_PREVIOUS: "IS_PREVIOUS";
        readonly AND: "AND";
        readonly OR: "OR";
    };
    type LogicalOperation = keyof typeof logicalOperations;
    type Operation = keyof typeof operations;
}
//# sourceMappingURL=types.d.ts.map