import { TableField } from "../components/inputs/table-field";
/**  */
export interface IComparison {
    /**
     * Desabilita as mudanças de valores quando em uma listagem
    */
    disableChange: boolean;
    /**
     * Tipo da comparação veja os tipos em ComparisonType
     */
    type: ComparisonType;
    /**
     * Seta o valor da comparação (utiliza o valor B)
     * @param value Valor a ser comparado
    */
    setValue(value: any): any;
    /**
     * Retorna o valor da comparação (utiliza o valor B)
     * @returns value Valor a ser comparado
    */
    getValue(): any;
    /**
     * @param comparison Comparação para ser utilizada em conjunto com a que está fazendo a chamada
     * @returns Retorna um comparação, equivalente a ```(A && B)```
    */
    And(comparison: IComparison): IComparison;
    /**
   * @param comparison Comparação para ser utilizada em conjunto com a que está fazendo a chamada
   * @returns Retorna um comparação, equivalente a ```(A || B)```
  */
    Or(comparison: IComparison): IComparison;
    /** Retorna o tipo da propriedade A  */
    GetAType(): any;
    /** Retorna o tipo da propriedade B  */
    GetBType(): any;
    /** Retorna o nome da propriedade A */
    GetPropAName(): any;
    /** Retorna o nome da propriedade B */
    GetPropBName(): any;
}
export declare class Comparison<T1, T2> implements IComparison {
    type: ComparisonType;
    /** Valor A para ser comparado */
    valueA: T1 | T2;
    /** Valor B para ser comparado */
    valueB: T1 | T2;
    /** Tipo do valor B para ser comparado, se for do tipo propriedade o valor vai ser comparado no db */
    valueAType: ComparisonValueType;
    /** Tipo do valor B para ser comparado, se for do tipo propriedade o valor vai ser comparado no db */
    valueBType: ComparisonValueType;
    /** Inverte a comparação, EX:
     *  ```!(A && B)```
     */
    not: boolean;
    disableChange: boolean;
    constructor(type: ComparisonType, 
    /** Valor A para ser comparado */
    valueA: T1 | T2, 
    /** Valor B para ser comparado */
    valueB: T1 | T2, 
    /** Tipo do valor B para ser comparado, se for do tipo propriedade o valor vai ser comparado no db */
    valueAType: ComparisonValueType, 
    /** Tipo do valor B para ser comparado, se for do tipo propriedade o valor vai ser comparado no db */
    valueBType: ComparisonValueType, 
    /** Inverte a comparação, EX:
     *  ```!(A && B)```
     */
    not?: boolean, disableChange?: boolean);
    setValue(value: T1 | T2): void;
    getValue(): T1 | T2;
    GetPropAName(): string;
    GetPropBName(): string;
    GetAType(): ComparisonValueType;
    GetBType(): ComparisonValueType;
    And<TA, TB>(comparison: Comparison<TA, TB>): Comparison<Comparison<T1, T2>, Comparison<TA, TB>>;
    Or<TA, TB>(comparison: Comparison<TA, TB>): Comparison<Comparison<T1, T2>, Comparison<TA, TB>>;
}
/** Retorna a comparação inversa: EX:
 * ```(A && B) -> !(A && B)```
 */
export declare function Not<T1, T2>(comparison: Comparison<T1, T2>): Comparison<T1, T2>;
/**
 * Compila todos os filtros validos para uma IComparison única, se não houver filtros validos, retornara nulo
 * @param lstTableFields lista de TableFields para compilar os filtros
 * @returns {IComparison} Filtro do tipo IComparison ou null
 */
export declare function CompileLstTableField(lstTableFields: TableField[]): IComparison | null;
/**
 * Compila uma lista de filtros em um só para ser enviado a API
 * @param lstFilter Lista de fitros a sem compilada
 * @returns Filtro do tipo IComparison
 */
export declare function CompileFilters(lstFilter: IComparison[]): IComparison;
/** Tipos de valores a serem comparados na filtragem de dados */
declare enum ComparisonValueType {
    Property = 0,
    Comparison = 1,
    Int = 2,
    Long = 3,
    Decimal = 4,
    String = 5,
    DateTime = 6,
    Date = 9,
    List = 7,
    Bool = 8,
    RouteParam = 10
}
export declare enum ComparisonType {
    And = 100,
    Or = 101,
    Not = 106,
    Equals = 200,
    BiggerThan = 201,
    BiggerThanOrEqual = 202,
    SmallerThan = 203,
    SmallerThanOrEqual = 204,
    EqualsCaseInsensitive = 200,
    Contains = 201
}
export declare class ComparisonValue {
    name: string;
    type: ComparisonValueType;
    constructor(name: string, type: ComparisonValueType);
}
export declare class NumberProperty extends ComparisonValue {
    constructor(name: string, type?: ComparisonValueType);
    Equals(n: number | null): Comparison<NumberProperty, number | null>;
    BiggerThan(n: number | null): Comparison<NumberProperty, number | null>;
    BiggerThanOrEqual(n: number | null): Comparison<NumberProperty, number | null>;
    SmallerThan(n: number | null): Comparison<NumberProperty, number | null>;
    SmallerThanOrEqual(n: number | null): Comparison<NumberProperty, number | null>;
}
/** Filtro para propriedades int e enum */
export declare class IntProperty extends NumberProperty {
    constructor(name: string);
    Contains(arr: (string | number)[]): Comparison<IntProperty, (string | number)[]>;
}
/** FIltro para proprieadades long */
export declare class LongProperty extends NumberProperty {
    constructor(name: string);
    Contains(arr: (string | number)[]): Comparison<LongProperty, (string | number)[]>;
}
/** Filtro de preopriedades decimal  */
export declare class DecimalProperty extends NumberProperty {
    constructor(name: string);
}
/** Paranetros para usos interno do pacote */
export declare class RouteParamProperty extends NumberProperty {
    constructor(name: string);
}
export declare class ImplicitProperty extends NumberProperty {
    constructor(name: string);
}
/** Filtro de comparação de string */
export declare class StringProperty extends ComparisonValue {
    constructor(name: string);
    Equals(string: string | null): Comparison<StringProperty, string | null>;
    Contains(string: string | null): Comparison<StringProperty, string | null>;
    EqualsCaseInsensitive(string: string | null): Comparison<StringProperty, string | null>;
}
/** Filtro de propriedades booleanas */
export declare class BoolProperty extends ComparisonValue {
    constructor(name: string);
    Equals(string: boolean | null): Comparison<BoolProperty, boolean | null>;
}
/** Filtro de datas */
export declare class DateProperty extends ComparisonValue {
    constructor(name: string, type?: ComparisonValueType);
    Equals(n: string | null): Comparison<DateProperty, string | null>;
    BiggerThan(n: string | null): Comparison<DateProperty, string | null>;
    BiggerThanOrEqual(n: string | null): Comparison<DateProperty, string | null>;
    SmallerThan(n: string | null): Comparison<DateProperty, string | null>;
    SmallerThanOrEqual(n: string | null): Comparison<DateProperty, string | null>;
}
/** FIltro de datas com tempo  */
export declare class DateTimeProperty extends DateProperty {
    constructor(name: string);
}
/** Filtro de lisras */
export declare class ListValue extends ComparisonValue {
    value: (number | string)[];
    constructor(value: (number | string)[]);
    Contains(n: number | string | ComparisonValue, valueBType?: ComparisonValueType): Comparison<ListValue, number | string | ComparisonValue>;
}
export {};