import { OperatorOption, OperationOperand, Operation } from '../expression.js';
import '@fajarnugraha37/error';

declare function bin(op: OperatorOption, left: OperationOperand, right: OperationOperand): Operation;
declare function iff(condition: OperationOperand, thenValue: OperationOperand, elseValue?: OperationOperand): Operation;
declare function when(value: OperationOperand, cases: Record<string, OperationOperand>, defaultCase?: OperationOperand): Operation;
declare const Compare: {
    readonly eq: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly neq: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly gt: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly gte: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly lt: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly lte: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly strictEq: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly strictNeq: (a: OperationOperand, b: OperationOperand) => Operation;
};
declare const MathOps: {
    readonly add: (...operands: OperationOperand[]) => Operation;
    readonly subtract: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly multiply: (...operands: OperationOperand[]) => Operation;
    readonly divide: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly modulo: (a: OperationOperand, b: OperationOperand) => Operation;
    readonly power: (base: OperationOperand, exponent: OperationOperand) => Operation;
    readonly min: (...operands: OperationOperand[]) => Operation;
    readonly max: (...operands: OperationOperand[]) => Operation;
    readonly abs: (operand: OperationOperand) => Operation;
    readonly round: (operand: OperationOperand) => Operation;
    readonly floor: (operand: OperationOperand) => Operation;
    readonly ceil: (operand: OperationOperand) => Operation;
};
declare const Logic: {
    readonly and: (...operands: OperationOperand[]) => Operation;
    readonly or: (...operands: OperationOperand[]) => Operation;
    readonly not: (operand: OperationOperand) => Operation;
    readonly xor: (a: OperationOperand, b: OperationOperand) => Operation;
};
declare const Str: {
    readonly concat: (...operands: OperationOperand[]) => Operation;
    readonly length: (str: OperationOperand) => Operation;
    readonly substring: (str: OperationOperand, start: OperationOperand, end?: OperationOperand) => Operation;
    readonly toLowerCase: (str: OperationOperand) => Operation;
    readonly toUpperCase: (str: OperationOperand) => Operation;
    readonly trim: (str: OperationOperand) => Operation;
    readonly contains: (str: OperationOperand, substring: OperationOperand) => Operation;
    readonly startsWith: (str: OperationOperand, prefix: OperationOperand) => Operation;
    readonly endsWith: (str: OperationOperand, suffix: OperationOperand) => Operation;
    readonly replace: (str: OperationOperand, search: OperationOperand, replacement: OperationOperand) => Operation;
    readonly split: (str: OperationOperand, separator: OperationOperand) => Operation;
};
declare const Arr: {
    readonly map: (array: OperationOperand, callback: OperationOperand) => Operation;
    readonly filter: (array: OperationOperand, predicate: OperationOperand) => Operation;
    readonly reduce: (array: OperationOperand, callback: OperationOperand, initial?: OperationOperand) => Operation;
    readonly find: (array: OperationOperand, predicate: OperationOperand) => Operation;
    readonly every: (array: OperationOperand, predicate: OperationOperand) => Operation;
    readonly some: (array: OperationOperand, predicate: OperationOperand) => Operation;
    readonly includes: (array: OperationOperand, value: OperationOperand) => Operation;
    readonly length: (array: OperationOperand) => Operation;
    readonly get: (array: OperationOperand, index: OperationOperand) => Operation;
    readonly slice: (array: OperationOperand, start: OperationOperand, end?: OperationOperand) => Operation;
};
declare const Is: {
    readonly null: (value: OperationOperand) => Operation;
    readonly defined: (value: OperationOperand) => Operation;
    readonly empty: (value: OperationOperand) => Operation;
    readonly string: (value: OperationOperand) => Operation;
    readonly number: (value: OperationOperand) => Operation;
    readonly boolean: (value: OperationOperand) => Operation;
    readonly array: (value: OperationOperand) => Operation;
    readonly object: (value: OperationOperand) => Operation;
    readonly email: (value: OperationOperand) => Operation;
    readonly url: (value: OperationOperand) => Operation;
};
declare const Obj: {
    readonly get: (obj: OperationOperand, key: OperationOperand) => Operation;
    readonly keys: (obj: OperationOperand) => Operation;
    readonly values: (obj: OperationOperand) => Operation;
    readonly entries: (obj: OperationOperand) => Operation;
    readonly has: (obj: OperationOperand, key: OperationOperand) => Operation;
    readonly merge: (...objects: OperationOperand[]) => Operation;
};
declare const DateTime: {
    readonly now: () => Operation;
    readonly date: (value: OperationOperand) => Operation;
    readonly format: (date: OperationOperand, format: OperationOperand) => Operation;
    readonly isBefore: (date1: OperationOperand, date2: OperationOperand) => Operation;
    readonly isAfter: (date1: OperationOperand, date2: OperationOperand) => Operation;
};
declare const HO: {
    readonly map: (iterable: OperationOperand, lambda: OperationOperand) => Operation;
    readonly reduce: (iterable: OperationOperand, lambda: OperationOperand, init?: OperationOperand) => Operation;
    readonly every: (iterable: OperationOperand, predicate: OperationOperand) => Operation;
    readonly some: (iterable: OperationOperand, predicate: OperationOperand) => Operation;
};
declare class FluentOps {
    private readonly operand;
    constructor(operand: OperationOperand);
    static from(operand: OperationOperand): FluentOps;
    add(...others: OperationOperand[]): FluentOps;
    subtract(other: OperationOperand): FluentOps;
    multiply(...others: OperationOperand[]): FluentOps;
    divide(other: OperationOperand): FluentOps;
    eq(other: OperationOperand): FluentOps;
    gt(other: OperationOperand): FluentOps;
    lt(other: OperationOperand): FluentOps;
    gte(other: OperationOperand): FluentOps;
    lte(other: OperationOperand): FluentOps;
    and(...others: OperationOperand[]): FluentOps;
    or(...others: OperationOperand[]): FluentOps;
    not(): FluentOps;
    map(callback: OperationOperand): FluentOps;
    filter(predicate: OperationOperand): FluentOps;
    find(predicate: OperationOperand): FluentOps;
    includes(value: OperationOperand): FluentOps;
    get(key: OperationOperand): FluentOps;
    concat(...others: OperationOperand[]): FluentOps;
    toLowerCase(): FluentOps;
    toUpperCase(): FluentOps;
    trim(): FluentOps;
    contains(substring: OperationOperand): FluentOps;
    isNull(): FluentOps;
    isDefined(): FluentOps;
    isEmpty(): FluentOps;
    if(thenValue: OperationOperand, elseValue?: OperationOperand): FluentOps;
    build(): Operation;
    value(): OperationOperand;
}
declare const $: typeof FluentOps.from;

export { $, Arr, Compare, DateTime, FluentOps, HO, Is, Logic, MathOps, Obj, Str, bin, iff, when };