import { TruthTable } from "./containers";
import { IEvaluable, IEvaluableNode, IFormulableNode } from "./interfaces";
import { Mappings } from "./mappings";
declare type UnaryOperation = (a: boolean) => boolean;
declare type BinaryOperation = (a: boolean, b: boolean) => boolean;
declare type UnaryFormulation = (a: IEvaluable) => IEvaluable;
declare type BinaryFormulation = (a: IEvaluable, b: IEvaluable) => IEvaluable;
declare abstract class EvaluableUnaryOperation implements IEvaluableNode {
    private _operation;
    private _symbol;
    protected _operand: IEvaluableNode;
    constructor(symbol: string, operand: IEvaluableNode, operation: UnaryOperation);
    get operand(): IEvaluableNode;
    evaluate(truthTable: TruthTable): boolean;
    toString(): string;
}
declare abstract class EvaluableBinaryOperation implements IEvaluableNode {
    private _operation;
    private _symbol;
    protected _operand: IEvaluableNode;
    protected _secondOperand: IEvaluableNode;
    constructor(symbol: string, operand: IEvaluableNode, secondOperand: IEvaluableNode, operation: BinaryOperation);
    get operand(): IEvaluableNode;
    get secondOperand(): IEvaluableNode;
    evaluate(truthTable: TruthTable): boolean;
    toString(): string;
}
export declare class EvaluableNegateOperation extends EvaluableUnaryOperation {
    constructor(operand: IEvaluableNode);
}
export declare class EvaluableAndOperation extends EvaluableBinaryOperation {
    constructor(operand: IEvaluableNode, secondOperand: IEvaluableNode);
}
export declare class EvaluableOrOperation extends EvaluableBinaryOperation {
    constructor(operand: IEvaluableNode, secondOperand: IEvaluableNode);
}
export declare class EvaluableImplicationOperation extends EvaluableBinaryOperation {
    constructor(operand: IEvaluableNode, secondOperand: IEvaluableNode);
}
export declare class EvaluableEquivalenceOperation extends EvaluableBinaryOperation {
    constructor(operand: IEvaluableNode, secondOperand: IEvaluableNode);
}
declare abstract class FormulableUnaryOperation implements IFormulableNode {
    private _symbol;
    private _operation;
    protected _operand: IFormulableNode;
    constructor(symbol: string, operand: IFormulableNode, operation: UnaryFormulation);
    get operand(): IFormulableNode;
    get variables(): string[];
    formulate(mappings: Mappings): IEvaluable;
    toString(): string;
}
declare abstract class FormulableBinaryOperation implements IFormulableNode {
    private _symbol;
    private _operation;
    protected _operand: IFormulableNode;
    protected _secondOperand: IFormulableNode;
    constructor(symbol: string, operand: IFormulableNode, secondOperand: IFormulableNode, operation: BinaryFormulation);
    get operand(): IFormulableNode;
    get secondOperand(): IFormulableNode;
    get variables(): string[];
    formulate(mappings: Mappings): IEvaluable;
    toString(): string;
}
export declare class FormulableNegateOperation extends FormulableUnaryOperation {
    constructor(operand: IFormulableNode);
}
export declare class FormulableAndOperation extends FormulableBinaryOperation {
    constructor(operand: IFormulableNode, secondOperand: IFormulableNode);
}
export declare class FormulableOrOperation extends FormulableBinaryOperation {
    constructor(operand: IFormulableNode, secondOperand: IFormulableNode);
}
export declare class FormulableImplicationOperation extends FormulableBinaryOperation {
    constructor(operand: IFormulableNode, secondOperand: IFormulableNode);
}
export declare class FormulableEquivalenceOperation extends FormulableBinaryOperation {
    constructor(operand: IFormulableNode, secondOperand: IFormulableNode);
}
export {};
//# sourceMappingURL=operations.d.ts.map