type Nullable<T> = T | null | undefined
declare function KtSingleton<T>(): T & (abstract new() => any);
export declare interface KtList<out E> /* extends Collection<E> */ {
    asJsReadonlyArrayView(): ReadonlyArray<E>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtList": unique symbol;
    };
}
export declare namespace KtList {
    function fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
}
export declare class Pair<out A, out B> /* implements Serializable */ {
    constructor(first: A, second: B);
    get first(): A;
    get second(): B;
    toString(): string;
    copy(first?: A, second?: B): Pair<A, B>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Pair {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new <A, B>() => Pair<A, B>;
    }
}
export declare interface BigDecimal /* extends Comparable<BigDecimal> */ {
    readonly absoluteValue: BigDecimal;
    readonly signum: number;
    readonly scale: number;
    readonly precision: number;
    readonly unscaledValue: BigInteger;
    plus(augend: Nullable<BigDecimal>): BigDecimal;
    plusWithContext(augend: Nullable<BigDecimal>, mc: MathContext): BigDecimal;
    minus(subtrahend: BigDecimal): BigDecimal;
    minusWithContext(subtrahend: BigDecimal, mc: MathContext): BigDecimal;
    times(multiplicand: Nullable<BigDecimal>): BigDecimal;
    timesWithContext(multiplicand: BigDecimal, mc: MathContext): BigDecimal;
    div(divisor: BigDecimal): BigDecimal;
    divWithContext(divisor: BigDecimal, mc: MathContext): Nullable<BigDecimal>;
    divideToIntegralValue(divisor: BigDecimal): BigDecimal;
    divideToIntegralValueWithContext(divisor: BigDecimal, mc: MathContext): BigDecimal;
    rem(divisor: BigDecimal): BigDecimal;
    remWithContext(divisor: BigDecimal, mc: MathContext): BigDecimal;
    divideAndRemainder(divisor: BigDecimal): Pair<BigDecimal, BigDecimal>;
    divideAndRemainderWithContext(divisor: BigDecimal, mc: MathContext): Pair<BigDecimal, BigDecimal>;
    sqrt(mc?: MathContext): BigDecimal;
    pow(n: number): BigDecimal;
    powWithContext(n: number, mc: MathContext): Nullable<BigDecimal>;
    absoluteValueWithContext(mc: MathContext): Nullable<BigDecimal>;
    unaryMinus(): BigDecimal;
    unaryMinusWithContext(mc: MathContext): Nullable<BigDecimal>;
    unaryPlus(): BigDecimal;
    unaryPlusWithContext(mc: MathContext): Nullable<BigDecimal>;
    round(mc: MathContext): Nullable<BigDecimal>;
    setScaleRounding(newScale: number, roundingMode: RoundingMode): BigDecimal;
    /** @deprecated The method {@link #setScale(int, RoundingMode)} should be used in preference to this legacy method. */
    setScaleInt(newScale: number, roundingMode: number): BigDecimal;
    setScale(newScale: number): BigDecimal;
    movePointLeft(n: number): BigDecimal;
    movePointRight(n: number): BigDecimal;
    scaleByPowerOfTen(n: number): BigDecimal;
    stripTrailingZeros(): BigDecimal;
    min(val: BigDecimal): BigDecimal;
    max(val: BigDecimal): BigDecimal;
    toEngineeringString(): string;
    toPlainString(): string;
    toBigInteger(): BigInteger;
    toBigIntegerExact(): BigInteger;
    toLong(): bigint;
    toLongExact(): bigint;
    toInt(): number;
    toByte(): number;
    toChar(): any/* Char */;
    toShort(): number;
    toIntExact(): number;
    toShortExact(): number;
    toByteExact(): number;
    toFloat(): number;
    toDouble(): number;
    ulp(): BigDecimal;
    readonly __doNotUseOrImplementIt: {
        readonly "org.gciatto.kt.math.BigDecimal": unique symbol;
    };
}
export declare namespace BigDecimal {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                get ZERO(): BigDecimal;
                get ONE(): BigDecimal;
                get TWO(): BigDecimal;
                get TEN(): BigDecimal;
                get ONE_TENTH(): BigDecimal;
                get ONE_HALF(): BigDecimal;
                get PI(): BigDecimal;
                get E(): BigDecimal;
                ofScaledLong(unscaledVal: bigint, scale: number): BigDecimal;
                ofScaledLongWithPrecision(unscaledVal: bigint, scale: number, prec: number): BigDecimal;
                ofInt(val: number): BigDecimal;
                of(val: bigint): BigDecimal;
                ofScaledBigIntegerWithPrecision(intVal: BigInteger, scale: number, prec: number): BigDecimal;
                ofDouble(val: number, ctx?: Nullable<MathContext>): BigDecimal;
                ofFloat(val: number, ctx?: Nullable<MathContext>): BigDecimal;
                parse(val: string, ctx?: Nullable<MathContext>): BigDecimal;
                ofBigInteger(val: BigInteger, ctx?: Nullable<MathContext>): BigDecimal;
                ofIntWithContext(val: number, ctx: MathContext): BigDecimal;
                ofWithContext(val: bigint, ctx: MathContext): BigDecimal;
                private constructor();
            }
        }
    }
}
export declare interface BigInteger /* extends Comparable<BigInteger> */ {
    readonly absoluteValue: BigInteger;
    readonly signum: number;
    readonly bitLength: number;
    readonly bitCount: number;
    rangeTo(endInclusive: BigInteger): BigIntegerRange;
    rangeToInt(endInclusive: number): BigIntegerRange;
    rangeToLong(endInclusive: bigint): BigIntegerRange;
    nextProbablePrime(): BigInteger;
    plus(other: BigInteger): BigInteger;
    plusInt(other: number): BigInteger;
    plusLong(other: bigint): BigInteger;
    minus(other: BigInteger): BigInteger;
    minusInt(other: number): BigInteger;
    minusLong(other: bigint): BigInteger;
    times(other: BigInteger): BigInteger;
    timesInt(other: number): BigInteger;
    timesLong(other: bigint): BigInteger;
    div(other: BigInteger): BigInteger;
    divInt(other: number): BigInteger;
    divLong(other: bigint): BigInteger;
    divideAndRemainder(other: BigInteger): Array<BigInteger>;
    divideAndRemainderInt(other: number): Array<BigInteger>;
    divideAndRemainderLong(other: bigint): Array<BigInteger>;
    reminder(other: BigInteger): BigInteger;
    reminderInt(other: number): BigInteger;
    reminderLong(other: bigint): BigInteger;
    pow(exponent: number): BigInteger;
    sqrt(): BigInteger;
    sqrtAndRemainder(): Array<BigInteger>;
    gcd(other: BigInteger): BigInteger;
    gcdInt(other: number): BigInteger;
    gcdLong(other: bigint): BigInteger;
    unaryMinus(): BigInteger;
    unaryPlus(): BigInteger;
    rem(modulus: BigInteger): BigInteger;
    remInt(modulus: number): BigInteger;
    remLong(modulus: bigint): BigInteger;
    modPow(exponent: BigInteger, modulus: BigInteger): BigInteger;
    modInverse(modulus: BigInteger): BigInteger;
    modInverseInt(modulus: number): BigInteger;
    modInverseLong(modulus: bigint): BigInteger;
    shl(n: number): BigInteger;
    shr(n: number): BigInteger;
    and(other: BigInteger): BigInteger;
    andInt(other: number): BigInteger;
    andLong(other: bigint): BigInteger;
    or(other: BigInteger): BigInteger;
    orInt(other: number): BigInteger;
    orLong(other: bigint): BigInteger;
    xor(other: BigInteger): BigInteger;
    xorInt(other: number): BigInteger;
    xorLong(other: bigint): BigInteger;
    not(): BigInteger;
    andNot(other: BigInteger): BigInteger;
    andNotInt(other: number): BigInteger;
    andNotLong(other: bigint): BigInteger;
    testBit(n: number): boolean;
    get(n: number): boolean;
    set(n: number, b: boolean): BigInteger;
    setBit(n: number): BigInteger;
    clearBit(n: number): BigInteger;
    flipBit(n: number): BigInteger;
    isProbablePrime(certainty: number): boolean;
    equals(other: Nullable<any>): boolean;
    min(other: BigInteger): BigInteger;
    max(other: BigInteger): BigInteger;
    hashCode(): number;
    toStringWithRadix(radix: number): string;
    toString(): string;
    toByteArray(): Int8Array;
    toInt(): number;
    toLong(): bigint;
    toByte(): number;
    toChar(): any/* Char */;
    toShort(): number;
    toFloat(): number;
    toDouble(): number;
    toLongExact(): bigint;
    toIntExact(): number;
    toShortExact(): number;
    toByteExact(): number;
    readonly __doNotUseOrImplementIt: {
        readonly "org.gciatto.kt.math.BigInteger": unique symbol;
    };
}
export declare namespace BigInteger {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                get ZERO(): BigInteger;
                get ONE(): BigInteger;
                get TWO(): BigInteger;
                get NEGATIVE_ONE(): BigInteger;
                get TEN(): BigInteger;
                probablePrime(bitLength: number, rnd: any/* Random */): BigInteger;
                ofLong(value: bigint): BigInteger;
                of(value: number): BigInteger;
                parse(value: string): BigInteger;
                parseWithRadix(value: string, radix: number): BigInteger;
                ofIntArray(value: Int32Array): BigInteger;
                ofSlideIntArray(signum: number, magnitude: Int8Array, off: number, len: number): BigInteger;
                private constructor();
            }
        }
    }
}
export declare class BigIntegerRange /* implements ClosedRange<BigInteger>, Iterable<BigInteger> */ {
    constructor(start: BigInteger, endInclusive: BigInteger);
    copy(start?: BigInteger, endInclusive?: BigInteger): BigIntegerRange;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace BigIntegerRange {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => BigIntegerRange;
    }
}
export declare class MathContext {
    constructor(precision?: number, roundingMode?: RoundingMode);
    get precision(): number;
    get roundingMode(): RoundingMode;
    copy(precision?: number, roundingMode?: RoundingMode): MathContext;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace MathContext {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => MathContext;
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                get UNLIMITED(): MathContext;
                get DECIMAL32(): MathContext;
                get DECIMAL64(): MathContext;
                get DECIMAL128(): MathContext;
                private constructor();
            }
        }
    }
}
export declare abstract class RoundingMode {
    private constructor();
    static get UP(): RoundingMode & {
        get name(): "UP";
        get ordinal(): 0;
    };
    static get DOWN(): RoundingMode & {
        get name(): "DOWN";
        get ordinal(): 1;
    };
    static get CEILING(): RoundingMode & {
        get name(): "CEILING";
        get ordinal(): 2;
    };
    static get FLOOR(): RoundingMode & {
        get name(): "FLOOR";
        get ordinal(): 3;
    };
    static get HALF_UP(): RoundingMode & {
        get name(): "HALF_UP";
        get ordinal(): 4;
    };
    static get HALF_DOWN(): RoundingMode & {
        get name(): "HALF_DOWN";
        get ordinal(): 5;
    };
    static get HALF_EVEN(): RoundingMode & {
        get name(): "HALF_EVEN";
        get ordinal(): 6;
    };
    static get UNNECESSARY(): RoundingMode & {
        get name(): "UNNECESSARY";
        get ordinal(): 7;
    };
    static values(): [typeof RoundingMode.UP, typeof RoundingMode.DOWN, typeof RoundingMode.CEILING, typeof RoundingMode.FLOOR, typeof RoundingMode.HALF_UP, typeof RoundingMode.HALF_DOWN, typeof RoundingMode.HALF_EVEN, typeof RoundingMode.UNNECESSARY];
    static valueOf(value: string): RoundingMode;
    get name(): "UP" | "DOWN" | "CEILING" | "FLOOR" | "HALF_UP" | "HALF_DOWN" | "HALF_EVEN" | "UNNECESSARY";
    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
    get value(): number;
}
export declare namespace RoundingMode {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => RoundingMode;
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                valueOfInt(rm: number): RoundingMode;
                private constructor();
            }
        }
    }
}
export declare function bigInteger(x: any): BigInteger;
export declare function bigDecimal(x: any): BigDecimal;
export declare class Answer {
    constructor(inStatements: KtList<Value>, outStatements: KtList<Value>, undStatements: KtList<Value>);
    get inStatements(): Array<Value>;
    get outStatements(): Array<Value>;
    get undStatements(): Array<Value>;
    label(statement: string): Nullable<string>;
    copy(inStatements?: KtList<Value>, outStatements?: KtList<Value>, undStatements?: KtList<Value>): Answer;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Answer {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Answer;
    }
}
export declare class Arg2pException extends /* Exception */ Error {
    constructor(message: string, syntax?: Nullable<SyntaxProblem>);
    get syntax(): Nullable<SyntaxProblem>;
}
export declare namespace Arg2pException {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Arg2pException;
    }
}
export declare abstract class Profile {
    private constructor();
    static get FREE(): Profile & {
        get name(): "FREE";
        get ordinal(): 0;
    };
    static get ASPIC_PLUS(): Profile & {
        get name(): "ASPIC_PLUS";
        get ordinal(): 1;
    };
    static get ASPIC(): Profile & {
        get name(): "ASPIC";
        get ordinal(): 2;
    };
    static get ASPIC_DEFEASIBLE(): Profile & {
        get name(): "ASPIC_DEFEASIBLE";
        get ordinal(): 3;
    };
    static get META(): Profile & {
        get name(): "META";
        get ordinal(): 4;
    };
    static get ABA(): Profile & {
        get name(): "ABA";
        get ordinal(): 5;
    };
    static get ABA_PLUS(): Profile & {
        get name(): "ABA_PLUS";
        get ordinal(): 6;
    };
    static get ABSTRACT(): Profile & {
        get name(): "ABSTRACT";
        get ordinal(): 7;
    };
    static values(): [typeof Profile.FREE, typeof Profile.ASPIC_PLUS, typeof Profile.ASPIC, typeof Profile.ASPIC_DEFEASIBLE, typeof Profile.META, typeof Profile.ABA, typeof Profile.ABA_PLUS, typeof Profile.ABSTRACT];
    static valueOf(value: string): Profile;
    get name(): "FREE" | "ASPIC_PLUS" | "ASPIC" | "ASPIC_DEFEASIBLE" | "META" | "ABA" | "ABA_PLUS" | "ABSTRACT";
    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
    get value(): string;
}
export declare namespace Profile {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Profile;
    }
}
export declare abstract class Semantics {
    private constructor();
    static get CONFLICT_FREE(): Semantics & {
        get name(): "CONFLICT_FREE";
        get ordinal(): 0;
    };
    static get ADMISSIBLE(): Semantics & {
        get name(): "ADMISSIBLE";
        get ordinal(): 1;
    };
    static get STRONGLY_ADMISSIBLE(): Semantics & {
        get name(): "STRONGLY_ADMISSIBLE";
        get ordinal(): 2;
    };
    static get GROUNDED(): Semantics & {
        get name(): "GROUNDED";
        get ordinal(): 3;
    };
    static get COMPLETE(): Semantics & {
        get name(): "COMPLETE";
        get ordinal(): 4;
    };
    static get PREFERRED(): Semantics & {
        get name(): "PREFERRED";
        get ordinal(): 5;
    };
    static get SEMI_STABLE(): Semantics & {
        get name(): "SEMI_STABLE";
        get ordinal(): 6;
    };
    static get STABLE(): Semantics & {
        get name(): "STABLE";
        get ordinal(): 7;
    };
    static get IDEAL(): Semantics & {
        get name(): "IDEAL";
        get ordinal(): 8;
    };
    static get EAGER(): Semantics & {
        get name(): "EAGER";
        get ordinal(): 9;
    };
    static get NAIVE(): Semantics & {
        get name(): "NAIVE";
        get ordinal(): 10;
    };
    static get STAGE(): Semantics & {
        get name(): "STAGE";
        get ordinal(): 11;
    };
    static get CF2(): Semantics & {
        get name(): "CF2";
        get ordinal(): 12;
    };
    static get STAGE2(): Semantics & {
        get name(): "STAGE2";
        get ordinal(): 13;
    };
    static get BP_GROUNDED(): Semantics & {
        get name(): "BP_GROUNDED";
        get ordinal(): 14;
    };
    static get BP_GROUNDED_PARTIAL(): Semantics & {
        get name(): "BP_GROUNDED_PARTIAL";
        get ordinal(): 15;
    };
    static get BP_GROUNDED_COMPLETE(): Semantics & {
        get name(): "BP_GROUNDED_COMPLETE";
        get ordinal(): 16;
    };
    static values(): [typeof Semantics.CONFLICT_FREE, typeof Semantics.ADMISSIBLE, typeof Semantics.STRONGLY_ADMISSIBLE, typeof Semantics.GROUNDED, typeof Semantics.COMPLETE, typeof Semantics.PREFERRED, typeof Semantics.SEMI_STABLE, typeof Semantics.STABLE, typeof Semantics.IDEAL, typeof Semantics.EAGER, typeof Semantics.NAIVE, typeof Semantics.STAGE, typeof Semantics.CF2, typeof Semantics.STAGE2, typeof Semantics.BP_GROUNDED, typeof Semantics.BP_GROUNDED_PARTIAL, typeof Semantics.BP_GROUNDED_COMPLETE];
    static valueOf(value: string): Semantics;
    get name(): "CONFLICT_FREE" | "ADMISSIBLE" | "STRONGLY_ADMISSIBLE" | "GROUNDED" | "COMPLETE" | "PREFERRED" | "SEMI_STABLE" | "STABLE" | "IDEAL" | "EAGER" | "NAIVE" | "STAGE" | "CF2" | "STAGE2" | "BP_GROUNDED" | "BP_GROUNDED_PARTIAL" | "BP_GROUNDED_COMPLETE";
    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16;
    get value(): string;
}
export declare namespace Semantics {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Semantics;
    }
}
export declare abstract class StatementLabelling {
    private constructor();
    static get STATEMENT(): StatementLabelling & {
        get name(): "STATEMENT";
        get ordinal(): 0;
    };
    static get STATEMENT_PASS_THROUGH(): StatementLabelling & {
        get name(): "STATEMENT_PASS_THROUGH";
        get ordinal(): 1;
    };
    static get STATEMENT_BINARY(): StatementLabelling & {
        get name(): "STATEMENT_BINARY";
        get ordinal(): 2;
    };
    static values(): [typeof StatementLabelling.STATEMENT, typeof StatementLabelling.STATEMENT_PASS_THROUGH, typeof StatementLabelling.STATEMENT_BINARY];
    static valueOf(value: string): StatementLabelling;
    get name(): "STATEMENT" | "STATEMENT_PASS_THROUGH" | "STATEMENT_BINARY";
    get ordinal(): 0 | 1 | 2;
    get value(): string;
}
export declare namespace StatementLabelling {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => StatementLabelling;
    }
}
export declare abstract class OrderingPrinciple {
    private constructor();
    static get LAST(): OrderingPrinciple & {
        get name(): "LAST";
        get ordinal(): 0;
    };
    static get WEAKEST(): OrderingPrinciple & {
        get name(): "WEAKEST";
        get ordinal(): 1;
    };
    static values(): [typeof OrderingPrinciple.LAST, typeof OrderingPrinciple.WEAKEST];
    static valueOf(value: string): OrderingPrinciple;
    get name(): "LAST" | "WEAKEST";
    get ordinal(): 0 | 1;
    get value(): string;
}
export declare namespace OrderingPrinciple {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => OrderingPrinciple;
    }
}
export declare abstract class OrderingComparator {
    private constructor();
    static get ELITIST(): OrderingComparator & {
        get name(): "ELITIST";
        get ordinal(): 0;
    };
    static get DEMOCRAT(): OrderingComparator & {
        get name(): "DEMOCRAT";
        get ordinal(): 1;
    };
    static get NORMAL(): OrderingComparator & {
        get name(): "NORMAL";
        get ordinal(): 2;
    };
    static values(): [typeof OrderingComparator.ELITIST, typeof OrderingComparator.DEMOCRAT, typeof OrderingComparator.NORMAL];
    static valueOf(value: string): OrderingComparator;
    get name(): "ELITIST" | "DEMOCRAT" | "NORMAL";
    get ordinal(): 0 | 1 | 2;
    get value(): string;
}
export declare namespace OrderingComparator {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => OrderingComparator;
    }
}
export declare abstract class GraphExtension {
    private constructor();
    static get REBUT_RESTRICTION(): GraphExtension & {
        get name(): "REBUT_RESTRICTION";
        get ordinal(): 0;
    };
    static get BP(): GraphExtension & {
        get name(): "BP";
        get ordinal(): 1;
    };
    static get STANDARD_PREF(): GraphExtension & {
        get name(): "STANDARD_PREF";
        get ordinal(): 2;
    };
    static get DEFEASIBLE_PREF(): GraphExtension & {
        get name(): "DEFEASIBLE_PREF";
        get ordinal(): 3;
    };
    static get DEFEASIBLE_ALL_PREF(): GraphExtension & {
        get name(): "DEFEASIBLE_ALL_PREF";
        get ordinal(): 4;
    };
    static get ABA_PREF(): GraphExtension & {
        get name(): "ABA_PREF";
        get ordinal(): 5;
    };
    static values(): [typeof GraphExtension.REBUT_RESTRICTION, typeof GraphExtension.BP, typeof GraphExtension.STANDARD_PREF, typeof GraphExtension.DEFEASIBLE_PREF, typeof GraphExtension.DEFEASIBLE_ALL_PREF, typeof GraphExtension.ABA_PREF];
    static valueOf(value: string): GraphExtension;
    get name(): "REBUT_RESTRICTION" | "BP" | "STANDARD_PREF" | "DEFEASIBLE_PREF" | "DEFEASIBLE_ALL_PREF" | "ABA_PREF";
    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5;
    get value(): string;
}
export declare namespace GraphExtension {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => GraphExtension;
    }
}
export declare abstract class GraphLanguage {
    private constructor();
    static get ASPIC_LANGUAGE(): GraphLanguage & {
        get name(): "ASPIC_LANGUAGE";
        get ordinal(): 0;
    };
    static get ABA_LANGUAGE(): GraphLanguage & {
        get name(): "ABA_LANGUAGE";
        get ordinal(): 1;
    };
    static get DEFEASIBLE_LANGUAGE(): GraphLanguage & {
        get name(): "DEFEASIBLE_LANGUAGE";
        get ordinal(): 2;
    };
    static get ABSTRACT_LANGUAGE(): GraphLanguage & {
        get name(): "ABSTRACT_LANGUAGE";
        get ordinal(): 3;
    };
    static values(): [typeof GraphLanguage.ASPIC_LANGUAGE, typeof GraphLanguage.ABA_LANGUAGE, typeof GraphLanguage.DEFEASIBLE_LANGUAGE, typeof GraphLanguage.ABSTRACT_LANGUAGE];
    static valueOf(value: string): GraphLanguage;
    get name(): "ASPIC_LANGUAGE" | "ABA_LANGUAGE" | "DEFEASIBLE_LANGUAGE" | "ABSTRACT_LANGUAGE";
    get ordinal(): 0 | 1 | 2 | 3;
    get value(): string;
}
export declare namespace GraphLanguage {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => GraphLanguage;
    }
}
export declare abstract class GraphBuilder {
    private constructor();
    static get RULE_GRAPH(): GraphBuilder & {
        get name(): "RULE_GRAPH";
        get ordinal(): 0;
    };
    static get ABSTRACT_GRAPH(): GraphBuilder & {
        get name(): "ABSTRACT_GRAPH";
        get ordinal(): 1;
    };
    static values(): [typeof GraphBuilder.RULE_GRAPH, typeof GraphBuilder.ABSTRACT_GRAPH];
    static valueOf(value: string): GraphBuilder;
    get name(): "RULE_GRAPH" | "ABSTRACT_GRAPH";
    get ordinal(): 0 | 1;
    get value(): string;
}
export declare namespace GraphBuilder {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => GraphBuilder;
    }
}
export declare abstract class ConflictModel {
    private constructor();
    static get BUILTIN(): ConflictModel & {
        get name(): "BUILTIN";
        get ordinal(): 0;
    };
    static get DECLARED(): ConflictModel & {
        get name(): "DECLARED";
        get ordinal(): 1;
    };
    static values(): [typeof ConflictModel.BUILTIN, typeof ConflictModel.DECLARED];
    static valueOf(value: string): ConflictModel;
    get name(): "BUILTIN" | "DECLARED";
    get ordinal(): 0 | 1;
    get value(): string;
}
export declare namespace ConflictModel {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => ConflictModel;
    }
}
export declare class Flags {
    private constructor();
    graphBuildMode(profile: Profile): Flags;
    argumentLabellingMode(semantics: Semantics): Flags;
    statementLabellingMode(labelling: StatementLabelling): Flags;
    orderingPrinciple(principle: OrderingPrinciple): Flags;
    orderingComparator(comparator: OrderingComparator): Flags;
    graphExtensions(extensions: Array<GraphExtension>): Flags;
    graphLanguage(languages: Array<GraphLanguage>): Flags;
    graphBuilder(builder: GraphBuilder): Flags;
    conflictModel(model: ConflictModel): Flags;
    modulesPath(path: string): Flags;
    queryMode(on: boolean): Flags;
    autoTransposition(on: boolean): Flags;
    prologStrictCompatibility(on: boolean): Flags;
    metaConflicts(on: boolean): Flags;
    metaRules(on: boolean): Flags;
    debug(on: boolean): Flags;
    toString(): string;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
    static defaults(): Flags;
    static none(): Flags;
    static parse(text: string): Flags;
}
export declare namespace Flags {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Flags;
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare class Solutions {
    private constructor();
    hasNext(): boolean;
    next(): Solution;
    toArray(limit?: number): Array<Solution>;
}
export declare namespace Solutions {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Solutions;
    }
}
export declare class Solution {
    private constructor();
    get isYes(): boolean;
    get isNo(): boolean;
    get isHalt(): boolean;
    get result(): string;
    get query(): string;
    get error(): Nullable<string>;
    get variables(): Array<string>;
    value(name: string): Nullable<Value>;
    text(name: string): Nullable<string>;
    toString(): string;
}
export declare namespace Solution {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Solution;
    }
}
export declare class SyntaxProblem {
    constructor(line: number, column: number, token: Nullable<string>, description: string);
    get line(): number;
    get column(): number;
    get token(): Nullable<string>;
    get description(): string;
    get length(): number;
    toString(): string;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
}
export declare namespace SyntaxProblem {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => SyntaxProblem;
    }
}
export declare abstract class Value {
    private constructor();
    abstract get kind(): string;
    toString(): string;
    static parse(text: string): Value;
    static struct(functor: string, args: Array<Value>): Value;
    static list(items: Array<Value>): Value;
}
export declare namespace Value {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Value;
    }
    class Atom extends Value.$metadata$.constructor {
        constructor(name: string);
        get name(): string;
        get kind(): string;
        toString(): string;
        copy(name?: string): Value.Atom;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    namespace Atom {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => Atom;
        }
    }
    class Integer extends Value.$metadata$.constructor {
        constructor(value: number);
        get value(): number;
        get kind(): string;
        toString(): string;
        copy(value?: number): Value.Integer;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    namespace Integer {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => Integer;
        }
    }
    class Real extends Value.$metadata$.constructor {
        constructor(value: number);
        get value(): number;
        get kind(): string;
        toString(): string;
        copy(value?: number): Value.Real;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    namespace Real {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => Real;
        }
    }
    class Variable extends Value.$metadata$.constructor {
        constructor(name: string);
        get name(): string;
        get kind(): string;
        toString(): string;
        copy(name?: string): Value.Variable;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    namespace Variable {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => Variable;
        }
    }
    class List extends Value.$metadata$.constructor {
        constructor(items: KtList<Value>);
        get kind(): string;
        get items(): Array<Value>;
        toString(): string;
        copy(items?: KtList<Value>): Value.List;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    namespace List {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => List;
        }
    }
    class Struct extends Value.$metadata$.constructor {
        constructor(functor: string, args: KtList<Value>);
        get functor(): string;
        get kind(): string;
        get args(): Array<Value>;
        get arity(): number;
        toString(): string;
        copy(functor?: string, args?: KtList<Value>): Value.Struct;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    namespace Struct {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => Struct;
        }
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare abstract class Arg2pPrologSolverFactory {
    static readonly getInstance: () => typeof Arg2pPrologSolverFactory.$metadata$.type;
    private constructor();
}
export declare namespace Arg2pPrologSolverFactory {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor /* implements SolverFactory */ {
            private constructor();
        }
    }
}
export declare class Argument {
    constructor(rules: KtList<string>, topRule: string, conclusion: string, groundings?: KtList<string>, defeasibleRules?: KtList<string>, defeasiblePremises?: KtList<string>, lastDefeasibleRules?: KtList<string>, term?: Nullable<any>/* Nullable<Term> */);
    get topRule(): string;
    get conclusion(): string;
    hashCode(): number;
    get identifier(): string;
    set identifier(value: string);
    get rules(): Array<string>;
    get supports(): Array<Argument>;
    get descriptor(): string;
    toString(): string;
    copy(rules?: KtList<string>, topRule?: string, conclusion?: string, groundings?: KtList<string>, defeasibleRules?: KtList<string>, defeasiblePremises?: KtList<string>, lastDefeasibleRules?: KtList<string>, term?: Nullable<any>/* Nullable<Term> */): Argument;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Argument {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Argument;
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare class Attack {
    constructor(attacker: Argument, target: Argument, type?: Nullable<string>, on?: Nullable<Argument>);
    get attacker(): Argument;
    get target(): Argument;
    get type(): Nullable<string>;
    get on(): Nullable<Argument>;
    toString(): string;
    copy(attacker?: Argument, target?: Argument, type?: Nullable<string>, on?: Nullable<Argument>): Attack;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Attack {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Attack;
    }
}
export declare class Graph {
    constructor(arguments: KtList<Argument>, attacks: KtList<Attack>, supports: KtList<Support>, labellings?: KtList<LabelledArgument>);
    get arguments(): Array<Argument>;
    get attacks(): Array<Attack>;
    get supports(): Array<Support>;
    get labellings(): Array<LabelledArgument>;
    label(argument: Argument): Nullable<string>;
    labelled(label: string): Array<Argument>;
    conclusions(label: string): Array<string>;
    copy(arguments?: KtList<Argument>, attacks?: KtList<Attack>, supports?: KtList<Support>, labellings?: KtList<LabelledArgument>): Graph;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Graph {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Graph;
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare class LabelledArgument {
    constructor(argument: Argument, label: string);
    get argument(): Argument;
    get label(): string;
    toString(): string;
    copy(argument?: Argument, label?: string): LabelledArgument;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace LabelledArgument {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => LabelledArgument;
    }
}
export declare class Support {
    constructor(supporter: Argument, supported: Argument);
    get supporter(): Argument;
    get supported(): Argument;
    toString(): string;
    copy(supporter?: Argument, supported?: Argument): Support;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Support {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Support;
    }
}
export declare class ClusterSolver {
    private constructor();
    get output(): (p0: string) => void;
    set output(value: (p0: string) => void);
    solve(goal: string): Solutions;
    answer(query: string): Answer;
    graphs(): Array<Graph>;
    graph(): Graph;
    stop(): void;
}
export declare namespace ClusterSolver {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => ClusterSolver;
    }
}
export declare class LocalCluster {
    constructor(parts?: Nullable<number>, flags?: Flags, scheduler?: any/* SequentialScheduler */, lends?: boolean);
    get flags(): Flags;
    set flags(value: Flags);
    load(theory: string): void;
    add(clause: string): void;
    reset(): void;
    solve(statement: string): EvaluationResponse;
    get solver(): ClusterSolver;
    get stats(): FederationStats;
}
export declare namespace LocalCluster {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => LocalCluster;
    }
}
export declare class FederationStats {
    constructor(site: string, sites: KtList<SiteStats>, evaluation: Nullable<EvaluationStats>, nearby?: KtList<NearbySite>);
    get site(): string;
    get evaluation(): Nullable<EvaluationStats>;
    get sites(): Array<SiteStats>;
    get nearby(): Array<NearbySite>;
    copy(site?: string, sites?: KtList<SiteStats>, evaluation?: Nullable<EvaluationStats>, nearby?: KtList<NearbySite>): FederationStats;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace FederationStats {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => FederationStats;
    }
}
export declare class NearbySite {
    constructor(id: string, name: string, address: string, requiresCode: boolean);
    get id(): string;
    get name(): string;
    get address(): string;
    get requiresCode(): boolean;
    copy(id?: string, name?: string, address?: string, requiresCode?: boolean): NearbySite;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace NearbySite {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => NearbySite;
    }
}
export declare class SiteStats {
    constructor(id: string, workers: Nullable<number>, delegate: boolean, via: Nullable<string>);
    get id(): string;
    get workers(): Nullable<number>;
    get delegate(): boolean;
    get via(): Nullable<string>;
    copy(id?: string, workers?: Nullable<number>, delegate?: boolean, via?: Nullable<string>): SiteStats;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace SiteStats {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => SiteStats;
    }
}
export declare class EvaluationStats {
    constructor(locality: string, arguments: number, attacks: number, added: number, workers: KtList<WorkerStats>, milliseconds: number);
    get locality(): string;
    get arguments(): number;
    get attacks(): number;
    get added(): number;
    get milliseconds(): number;
    get workers(): Array<WorkerStats>;
    copy(locality?: string, arguments?: number, attacks?: number, added?: number, workers?: KtList<WorkerStats>, milliseconds?: number): EvaluationStats;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace EvaluationStats {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => EvaluationStats;
    }
}
export declare class WorkerStats {
    constructor(partition: number, site: string, arguments: number, attacks: number);
    get partition(): number;
    get site(): string;
    get arguments(): number;
    get attacks(): number;
    copy(partition?: number, site?: string, arguments?: number, attacks?: number): WorkerStats;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace WorkerStats {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => WorkerStats;
    }
}
export declare class Response {
    constructor(claim: string, queryChain: KtList<string>);
    get claim(): string;
    get queryChain(): Array<string>;
    copy(claim?: string, queryChain?: KtList<string>): Response;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace Response {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Response;
    }
}
export declare class EvaluationResponse /* implements KbMessage */ {
    constructor(inArgs: KtList<Response>, outArgs: KtList<Response>, undArgs: KtList<Response>, error?: Nullable<string>);
    get error(): Nullable<string>;
    get inArgs(): Array<Response>;
    get outArgs(): Array<Response>;
    get undArgs(): Array<Response>;
    copy(inArgs?: KtList<Response>, outArgs?: KtList<Response>, undArgs?: KtList<Response>, error?: Nullable<string>): EvaluationResponse;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
export declare namespace EvaluationResponse {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => EvaluationResponse;
    }
}
export declare class AsyncClusterSolver {
    private constructor();
    get output(): (p0: string) => void;
    set output(value: (p0: string) => void);
    solve(goal: string): Promise<AsyncSolutions>;
    answer(query: string): Promise<Answer>;
    graphs(): Promise<Array<Graph>>;
    graph(): Graph;
    stop(): void;
}
export declare namespace AsyncClusterSolver {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => AsyncClusterSolver;
    }
}
export declare class AsyncSolutions {
    private constructor();
    hasNext(): boolean;
    next(): Promise<Solution>;
    toArray(limit?: number): Promise<Array<Solution>>;
}
export declare namespace AsyncSolutions {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => AsyncSolutions;
    }
}
export declare class WebWorkerCluster {
    constructor(threads: number, worker: string, parts?: Nullable<number>, flags?: Flags, iceServers?: Array<any>);
    connect(url: string, code?: Nullable<string>): Promise<void>;
    invite(): Promise<string>;
    accept(invitation: string): Promise<string>;
    complete(reply: string): Promise<void>;
    get peers(): Array<string>;
    get onPeersChanged(): Nullable<() => void>;
    set onPeersChanged(value: Nullable<() => void>);
    get stats(): FederationStats;
    get flags(): Flags;
    set flags(value: Flags);
    load(theory: string): void;
    add(clause: string): void;
    reset(): void;
    solve(statement: string): Promise<EvaluationResponse>;
    get solver(): AsyncClusterSolver;
    close(): void;
}
export declare namespace WebWorkerCluster {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => WebWorkerCluster;
    }
}
export declare function startWebWorker(): void;
export declare class WorkerCluster {
    constructor(threads: number, parts?: Nullable<number>, flags?: Flags, module?: Nullable<string>);
    listen(port?: number): Promise<number>;
    discover(beaconPort?: number, requireCode?: boolean): Promise<number>;
    connect(url: string, code?: Nullable<string>): Promise<void>;
    get name(): string;
    set name(value: string);
    get requiresCode(): boolean;
    set requiresCode(value: boolean);
    get code(): string;
    newCode(): string;
    get nearby(): Array<NearbySite>;
    get onNearbyChanged(): Nullable<() => void>;
    set onNearbyChanged(value: Nullable<() => void>);
    pair(site: string, code: string): Promise<void>;
    get peers(): Array<string>;
    get onPeersChanged(): Nullable<() => void>;
    set onPeersChanged(value: Nullable<() => void>);
    get stats(): FederationStats;
    get flags(): Flags;
    set flags(value: Flags);
    load(theory: string): void;
    add(clause: string): void;
    reset(): void;
    solve(statement: string): Promise<EvaluationResponse>;
    get solver(): AsyncClusterSolver;
    close(): void;
}
export declare namespace WorkerCluster {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => WorkerCluster;
    }
}
export declare function startWorkerThread(): void;
export declare class Arg2p {
    private constructor();
    get causality(): Causality;
    get theory(): string;
    answer(query: string): Answer;
    graphs(): Array<Graph>;
    graph(): Graph;
    graphAt(branch: number): Graph;
    get activeBranch(): number;
    get knownFlags(): Array<string>;
    setting(flag: string): Array<string>;
    solve(goal: string): Solutions;
    contextFacts(branch: number, goal: string): Solutions;
    add(theory: string): void;
    load(theory: string): void;
    static of(theory?: string, flags?: Flags): Arg2p;
    static builder(): Arg2p.Builder;
    static checkTheory(theory: string): Nullable<SyntaxProblem>;
    static checkQuery(query: string): Nullable<SyntaxProblem>;
    static version(): string;
}
export declare namespace Arg2p {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Arg2p;
    }
    class Builder {
        constructor();
        theory(theory: string): Arg2p.Builder;
        flags(flags: Flags): Arg2p.Builder;
        output(consumer: (p0: string) => void): Arg2p.Builder;
        build(): Arg2p;
    }
    namespace Builder {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            const constructor: abstract new () => Builder;
        }
    }
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    namespace Companion {
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace $metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare abstract class Arg2pLibrary {
    static readonly getInstance: () => typeof Arg2pLibrary.$metadata$.type;
    private constructor();
}
export declare namespace Arg2pLibrary {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            version(): string;
            private constructor();
        }
    }
}
export declare class Causality {
    private constructor();
    ness(cause: string, effect: string): Nullable<Value>;
    nessOriginal(cause: string, effect: string): Nullable<Value>;
    nessIntervention(intervention: string, effect: string): boolean;
    nessOriginalIntervention(intervention: string, effect: string): boolean;
    butFor(cause: string, effect: string): boolean;
}
export declare namespace Causality {
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace $metadata$ {
        const constructor: abstract new () => Causality;
    }
}