type Nullable<T> = T | null | undefined
declare function KtSingleton<T>(): T & (abstract new() => any);
export declare interface KtList<E> /* extends Collection<E> */ {
    asJsReadonlyArrayView(): ReadonlyArray<E>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtList": unique symbol;
    };
}
export declare abstract class KtList<E> {
    static readonly getInstance: () => typeof KtList.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtList.$metadata$ {
    abstract class type<E> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
        private constructor();
    }
}
export declare interface KtSet<E> /* extends Collection<E> */ {
    asJsReadonlySetView(): ReadonlySet<E>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtSet": unique symbol;
    };
}
export declare abstract class KtSet<E> {
    static readonly getInstance: () => typeof KtSet.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtSet.$metadata$ {
    abstract class type<E> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        fromJsSet<E>(set: ReadonlySet<E>): KtSet<E>;
        private constructor();
    }
}
export declare interface KtMap<K, V> {
    asJsReadonlyMapView(): ReadonlyMap<K, V>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtMap": unique symbol;
    };
}
export declare abstract class KtMap<K, V> {
    static readonly getInstance: () => typeof KtMap.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtMap.$metadata$ {
    abstract class type<K, V> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMap<K, V>;
        private constructor();
    }
}
export declare interface KtMutableMap<K, V> extends KtMap<K, V> {
    asJsMapView(): Map<K, V>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtMutableMap": unique symbol;
    } & KtMap<K, V>["__doNotUseOrImplementIt"];
}
export declare abstract class KtMutableMap<K, V> {
    static readonly getInstance: () => typeof KtMutableMap.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtMutableMap.$metadata$ {
    abstract class type<K, V> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMutableMap<K, V>;
        private constructor();
    }
}
export declare interface KtMutableSet<E> extends KtSet<E>/*, MutableCollection<E> */ {
    asJsSetView(): Set<E>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtMutableSet": unique symbol;
    } & KtSet<E>["__doNotUseOrImplementIt"];
}
export declare abstract class KtMutableSet<E> {
    static readonly getInstance: () => typeof KtMutableSet.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtMutableSet.$metadata$ {
    abstract class type<E> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        fromJsSet<E>(set: ReadonlySet<E>): KtMutableSet<E>;
        private constructor();
    }
}
export declare interface KtMutableList<E> extends KtList<E>/*, MutableCollection<E> */ {
    asJsArrayView(): Array<E>;
    readonly __doNotUseOrImplementIt: {
        readonly "kotlin.collections.KtMutableList": unique symbol;
    } & KtList<E>["__doNotUseOrImplementIt"];
}
export declare abstract class KtMutableList<E> {
    static readonly getInstance: () => typeof KtMutableList.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace KtMutableList.$metadata$ {
    abstract class type<E> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        fromJsArray<E>(array: ReadonlyArray<E>): KtMutableList<E>;
        private constructor();
    }
}
export declare class AnySerializer /* implements KSerializer<any> */ {
    constructor(customSerialize?: (p0: any) => any/* Pair<string, JsonObject> */, customDeserialize?: (p0: string, p1: KtMap<string, any/* JsonElement */>/* JsonObject */) => any);
    get customSerialize(): (p0: any) => any/* Pair<string, JsonObject> */;
    get customDeserialize(): (p0: string, p1: KtMap<string, any/* JsonElement */>/* JsonObject */) => any;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AnySerializer.$metadata$ {
    const constructor: abstract new () => AnySerializer;
}
export declare namespace AnySerializer {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get CLASS_DISCRIMINATOR(): string;
            private constructor();
        }
    }
}
export declare interface Builder<T extends any> {
    build(): T;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.Builder": unique symbol;
    };
}
export declare abstract class Builder<T extends any> {
    static readonly getInstance: () => typeof Builder.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Builder.$metadata$ {
    abstract class type<T extends any> extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        buildAction<B extends Builder<T>, T extends any>(ctor: () => B, init: (p0: B) => void, action: (p0: T) => void): T;
        private constructor();
    }
}
export declare class Indent {
    constructor(value?: string, increment?: string);
    get value(): string;
    get increment(): string;
    get inc(): Indent;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Indent.$metadata$ {
    const constructor: abstract new () => Indent;
}
export declare interface Reference<R extends any, T extends any> {
    readonly reference: Nullable<R>;
    readonly resolved: Nullable<T>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.Reference": unique symbol;
    };
}
export declare interface MutableReference<R extends any, T extends any> extends Reference<R, T> {
    reference: Nullable<R>;
    set(ref: Nullable<R>, value: Nullable<T>): void;
    clear(): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.MutableReference": unique symbol;
    } & Reference<R, T>["__doNotUseOrImplementIt"];
}
export declare class ReferenceImmutable<R extends any, T extends any> implements Reference<R, T> {
    constructor(reference: Nullable<R>);
    get reference(): Nullable<R>;
    set reference(value: Nullable<R>);
    static new_net_akehurst_kotlinx_utils_ReferenceImmutable<R extends any, T extends any>(reference: Nullable<R>, resolved: Nullable<T>): ReferenceImmutable<R, T>;
    get resolved(): Nullable<T>;
    set resolved(value: Nullable<T>);
    copy(reference?: Nullable<R>): ReferenceImmutable<R, T>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Reference<R, T>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceImmutable.$metadata$ {
    const constructor: abstract new <R extends any, T extends any>() => ReferenceImmutable<R, T>;
}
export declare abstract class ReferenceExt {
    static readonly getInstance: () => typeof ReferenceExt.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceExt.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        private constructor();
    }
}
export declare class MutableReferenceDefault<R extends any, T extends any> implements MutableReference<R, T> {
    constructor(reference?: Nullable<R>);
    get reference(): Nullable<R>;
    set reference(value: Nullable<R>);
    get resolved(): Nullable<T>;
    set resolved(value: Nullable<T>);
    set(ref: Nullable<R>, value: Nullable<T>): void;
    clear(): void;
    copy(reference?: Nullable<R>): MutableReferenceDefault<R, T>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: MutableReference<R, T>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MutableReferenceDefault.$metadata$ {
    const constructor: abstract new <R extends any, T extends any>() => MutableReferenceDefault<R, T>;
}
export declare interface ReferenceStore<R extends any> {
    get<T extends any>(clazz: any/* KClass<T> */, reference: R): Nullable<T>;
    set<T extends any>(clazz: any/* KClass<T> */, reference: R, value: Nullable<T>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.ReferenceStore": unique symbol;
    };
}
export declare interface HierarchicalReferenceStore<R extends any> extends ReferenceStore<R> {
    readonly identity: R;
    readonly parentReferenceStore: Nullable<HierarchicalReferenceStore<R>>;
    readonly rootReferenceStore: HierarchicalReferenceStore<R>;
    registerChild(child: HierarchicalReferenceStore<R>): void;
    getOwnerForReferenceType<T extends any>(clazz: any/* KClass<T> */): Nullable<ReferenceStore<R>>;
    setOwnerForReferenceType<T extends any>(clazz: any/* KClass<T> */, store: ReferenceStore<R>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.HierarchicalReferenceStore": unique symbol;
    } & ReferenceStore<R>["__doNotUseOrImplementIt"];
}
export declare class ReferenceStoreByHashMap<R extends any> implements ReferenceStore<R> {
    constructor();
    get<T extends any>(clazz: any/* KClass<T> */, reference: R): Nullable<T>;
    set<T extends any>(clazz: any/* KClass<T> */, reference: R, value: Nullable<T>): void;
    readonly __doNotUseOrImplementIt: ReferenceStore<R>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceStoreByHashMap.$metadata$ {
    const constructor: abstract new <R extends any>() => ReferenceStoreByHashMap<R>;
}
export declare class HierarchicalReferenceStoreByHashMap<R extends any> implements HierarchicalReferenceStore<R> {
    constructor(parentReferenceStore: Nullable<HierarchicalReferenceStore<R>>, identity: R);
    get parentReferenceStore(): Nullable<HierarchicalReferenceStore<R>>;
    get identity(): R;
    get rootReferenceStore(): HierarchicalReferenceStore<R>;
    get<T extends any>(clazz: any/* KClass<T> */, reference: R): Nullable<T>;
    set<T extends any>(clazz: any/* KClass<T> */, reference: R, value: Nullable<T>): void;
    registerChild(child: HierarchicalReferenceStore<R>): void;
    getOwnerForReferenceType<T extends any>(clazz: any/* KClass<T> */): Nullable<ReferenceStore<R>>;
    setOwnerForReferenceType<T extends any>(clazz: any/* KClass<T> */, store: ReferenceStore<R>): void;
    readonly __doNotUseOrImplementIt: HierarchicalReferenceStore<R>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace HierarchicalReferenceStoreByHashMap.$metadata$ {
    const constructor: abstract new <R extends any>() => HierarchicalReferenceStoreByHashMap<R>;
}
export declare function toRegexFromGlob(_this_: string, separator: any/* Char */, options?: KtSet<any/* RegexOption */>): any/* Regex */;
export declare class UniqueIdentityGenerator {
    constructor(commonPrefix?: string);
    get commonPrefix(): string;
    generate(prefix?: string): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace UniqueIdentityGenerator.$metadata$ {
    const constructor: abstract new () => UniqueIdentityGenerator;
}
export declare namespace UniqueIdentityGenerator {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get GLOBAL(): UniqueIdentityGenerator;
            private constructor();
        }
    }
}
export declare interface Value<T> {
    get(): T;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.Value": unique symbol;
    };
}
export declare class ValueImmutable<T> implements Value<T> {
    constructor(value: T);
    get value(): T;
    get(): T;
    copy(value?: T): ValueImmutable<T>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Value<T>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ValueImmutable.$metadata$ {
    const constructor: abstract new <T>() => ValueImmutable<T>;
}
export declare interface MutableValue<T> extends Value<T> {
    set(value: T): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.MutableValue": unique symbol;
    } & Value<T>["__doNotUseOrImplementIt"];
}
export declare abstract class ValueExt {
    static readonly getInstance: () => typeof ValueExt.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ValueExt.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        private constructor();
    }
}
export declare abstract class MutableValueAbstract<T> implements MutableValue<T> {
    constructor();
    abstract get value(): T;
    abstract set value(value: T);
    get(): T;
    set(value: T): void;
    readonly __doNotUseOrImplementIt: MutableValue<T>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MutableValueAbstract.$metadata$ {
    const constructor: abstract new <T>() => MutableValueAbstract<T>;
}
export declare class MutableValueDefault<T> extends MutableValueAbstract.$metadata$.constructor<T> {
    constructor(value: T);
    get value(): T;
    set value(value: T);
    copy(value?: T): MutableValueDefault<T>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MutableValueDefault.$metadata$ {
    const constructor: abstract new <T>() => MutableValueDefault<T>;
}
export declare function asyncLazy<T>(initializer: any /*Suspend functions are not supported*/): any/* ReadOnlyProperty<Nullable<any>, AsyncLazy<T>> */;
export declare class AsyncLazy<T> {
    constructor(initializer: any /*Suspend functions are not supported*/);
    get initializer(): any /*Suspend functions are not supported*/;
    isInitialized(): boolean;
    invoke($completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    await($completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsyncLazy.$metadata$ {
    const constructor: abstract new <T>() => AsyncLazy<T>;
}
export declare interface Factory {
    readonly identity: any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.Factory": unique symbol;
    };
}
export declare interface HierarchicalFactory extends Factory {
    readonly parentFactory: Nullable<HierarchicalFactory>;
    readonly rootFactory: HierarchicalFactory;
    readonly qualifiedIdentity: KtList<any>;
    readonly qualifiedName: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.HierarchicalFactory": unique symbol;
    } & Factory["__doNotUseOrImplementIt"];
}
export declare interface Identifiable<I extends any> {
    readonly identity: I;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.Identifiable": unique symbol;
    };
}
export declare interface NestedIdentifiable<I extends any> extends Identifiable<I> {
    readonly parent: Nullable<NestedIdentifiable<I>>;
    readonly rootIdentifiable: Identifiable<I>;
    readonly qualifiedIdentity: KtList<I>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.NestedIdentifiable": unique symbol;
    } & Identifiable<I>["__doNotUseOrImplementIt"];
}
export declare interface Resolver {
    readonly identity: any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.Resolver": unique symbol;
    };
}
export declare interface HierarchicalResolver extends Resolver {
    readonly parentResolver: Nullable<HierarchicalResolver>;
    readonly rootResolver: HierarchicalResolver;
    readonly qualifiedIdentity: KtList<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.utils.HierarchicalResolver": unique symbol;
    } & Resolver["__doNotUseOrImplementIt"];
}
export declare function setJsAny<T extends any>(_this_: T, key: string, value: any): T;
export declare function getJsAny<T extends any>(_this_: T, key: string): T;
export declare function adoptCss(_this_: Document, css: string): void;
export declare function lazyMap<K, V>(accessor: (p0: K) => V): LazyMap<K, V>;
export declare class LazyMap<K, V> implements KtMap<K, V> {
    constructor(accessor: (p0: K) => V);
    get accessor(): (p0: K) => V;
    get map(): KtMutableMap<K, V>;
    asJsReadonlyMapView(): ReadonlyMap<K, V>;
    readonly __doNotUseOrImplementIt: KtMap<K, V>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LazyMap.$metadata$ {
    const constructor: abstract new <K, V>() => LazyMap<K, V>;
}
export declare function lazyMapNotNull<K, V>(accessor: (p0: K) => V): MapNotNull<K, V>/* LazyMapNotNull<K, V> */;
export declare function lazyMutableMapNotNull<K, V>(accessor: (p0: K) => V): MutableMapNotNull<K, V>/* LazyMutableMapNotNull<K, V> */;
export declare interface MapNotNull<K, V> extends KtMap<K, V> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.MapNotNull": unique symbol;
    } & KtMap<K, V>["__doNotUseOrImplementIt"];
}
export declare interface MutableMapNotNull<K, V> extends MapNotNull<K, V>, KtMutableMap<K, V> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.MutableMapNotNull": unique symbol;
    } & MapNotNull<K, V>["__doNotUseOrImplementIt"] & KtMutableMap<K, V>["__doNotUseOrImplementIt"];
}
export declare class MutableMapNonNullDefault<K, V> implements MutableMapNotNull<K, V>, KtMutableMap<K, V> {
    constructor(map: KtMutableMap<K, V>);
    asJsReadonlyMapView(): ReadonlyMap<K, V>;
    get size(): number;
    get keys(): KtMutableSet<K>;
    get values(): any/* MutableCollection<V> */;
    get entries(): KtMutableSet<any/* KtMutableMap.MutableEntry<K, V> */>;
    asJsMapView(): Map<K, V>;
    readonly __doNotUseOrImplementIt: MutableMapNotNull<K, V>["__doNotUseOrImplementIt"] & KtMutableMap<K, V>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MutableMapNonNullDefault.$metadata$ {
    const constructor: abstract new <K, V>() => MutableMapNonNullDefault<K, V>;
}
export declare function mutableStackOf<T>(elements: Array<T>): any/* MutableStack<T> */;
export declare interface OrderedSet<E> extends KtSet<E> {
    get(index: number): E;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.OrderedSet": unique symbol;
    } & KtSet<E>["__doNotUseOrImplementIt"];
}
export declare interface MutableOrderedSet<E> extends OrderedSet<E>, KtMutableSet<E> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.MutableOrderedSet": unique symbol;
    } & OrderedSet<E>["__doNotUseOrImplementIt"] & KtMutableSet<E>["__doNotUseOrImplementIt"];
}
export declare function emptyOrderedSet<T>(): OrderedSet<T>;
export declare function orderedSetOf<E>(elements: Array<E>): OrderedSet<E>;
export declare function mutableOrderedSetOf<E>(elements: Array<E>): MutableOrderedSet<E>;
export declare function toOrderedSet<T>(_this_: any/* Iterable<T> */): OrderedSet<T>;
export declare function toMutableOrderedSet<T>(_this_: any/* Iterable<T> */): MutableOrderedSet<T>;
export declare function plus<T>(_this_: OrderedSet<T>, element: T): OrderedSet<T>;
export declare function plusAll<T>(_this_: OrderedSet<T>, elements: any/* Iterable<T> */): OrderedSet<T>;
export declare function plusAssign<T>(_this_: MutableOrderedSet<T>, elements: any/* Iterable<T> */): void;
export declare class OrderedSetImpl<E> implements OrderedSet<E> {
    private constructor();
    static new_net_akehurst_kotlinx_collections_OrderedSetImpl<E>(collection: any/* Collection<E> */): OrderedSetImpl<E>;
    get(index: number): E;
    get size(): number;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
    toString(): string;
    asJsReadonlySetView(): ReadonlySet<E>;
    readonly __doNotUseOrImplementIt: OrderedSet<E>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OrderedSetImpl.$metadata$ {
    const constructor: abstract new <E>() => OrderedSetImpl<E>;
}
export declare class MutableOrderedSetImpl<E> implements MutableOrderedSet<E> {
    private constructor();
    static new_net_akehurst_kotlinx_collections_MutableOrderedSetImpl<E>(collection: any/* Collection<E> */): MutableOrderedSetImpl<E>;
    get(index: number): E;
    get size(): number;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
    toString(): string;
    asJsReadonlySetView(): ReadonlySet<E>;
    asJsSetView(): Set<E>;
    readonly __doNotUseOrImplementIt: MutableOrderedSet<E>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MutableOrderedSetImpl.$metadata$ {
    const constructor: abstract new <E>() => MutableOrderedSetImpl<E>;
}
export declare class Stack<T> {
    constructor(elements?: KtList<T>);
    get elements(): KtList<T>;
    get size(): number;
    get isEmpty(): boolean;
    get isNotEmpty(): boolean;
    push(item: T): Stack<T>;
    pushAll(items: KtList<T>): Stack<T>;
    peek(): T;
    peekOrNull(): Nullable<T>;
    pop(): Stack.PopResult<T>;
    clone(): Stack<T>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Stack.$metadata$ {
    const constructor: abstract new <T>() => Stack<T>;
}
export declare namespace Stack {
    class PopResult<T> {
        constructor(item: T, stack: Stack<T>);
        get item(): T;
        get stack(): Stack<T>;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace PopResult.$metadata$ {
        const constructor: abstract new <T>() => PopResult<T>;
    }
}
export declare function cachedByKeySuspend<IN, OUT>(initializer: any /*Suspend functions are not supported*/): CachedValueSuspend<IN, OUT>;
export declare class CachedValueSuspend<IN, OUT> {
    constructor(initializer: any /*Suspend functions are not supported*/);
    get initializer(): any /*Suspend functions are not supported*/;
    set initializer(value: any /*Suspend functions are not supported*/);
    containsKey(key: IN): boolean;
    getCachedValueOrNull(key: IN): Nullable<OUT>;
    get(key: IN, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    set(key: IN, value: OUT): void;
    reset(key: IN): void;
    resetAll(): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CachedValueSuspend.$metadata$ {
    const constructor: abstract new <IN, OUT>() => CachedValueSuspend<IN, OUT>;
}
export declare function cachedByKey<IN, OUT>(initializer: (p0: IN) => OUT): CachedValue<IN, OUT>;
export declare class CachedValue<IN, OUT> {
    constructor(initializer: (p0: IN) => OUT);
    get initializer(): (p0: IN) => OUT;
    set initializer(value: (p0: IN) => OUT);
    containsKey(key: IN): boolean;
    getCachedValueOrNull(key: IN): Nullable<OUT>;
    get(key: IN): Nullable<OUT>;
    set(key: IN, value: OUT): void;
    reset(key: IN): void;
    resetAll(): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CachedValue.$metadata$ {
    const constructor: abstract new <IN, OUT>() => CachedValue<IN, OUT>;
}
export declare class GraphNodeId {
    constructor(value: string);
    get value(): string;
    copy(value?: string): GraphNodeId;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphNodeId.$metadata$ {
    const constructor: abstract new () => GraphNodeId;
}
export declare class GraphEdgeId {
    constructor(value: string);
    get value(): string;
    copy(value?: string): GraphEdgeId;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphEdgeId.$metadata$ {
    const constructor: abstract new () => GraphEdgeId;
}
export declare interface Graph {
    readonly nodes: any/* Iterable<GraphNode> */;
    readonly edges: any/* Iterable<GraphEdge> */;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.Graph": unique symbol;
    };
}
export declare interface GraphNode {
    readonly id: GraphNodeId;
    readonly incoming: any/* Iterable<GraphEdge> */;
    readonly outgoing: any/* Iterable<GraphEdge> */;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.GraphNode": unique symbol;
    };
}
export declare interface GraphEdge {
    readonly id: GraphEdgeId;
    readonly ends: any/* Iterable<GraphNode> */;
    readonly source: GraphNode;
    readonly target: GraphNode;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.GraphEdge": unique symbol;
    };
}
export declare class GraphFunctions<NT extends any, ET extends any> {
    constructor(nodeIds: () => any/* Sequence<GraphNodeId> */, node: (p0: GraphNodeId) => NT, incoming: (p0: GraphNodeId) => any/* Sequence<GraphEdgeId> */, outgoing: (p0: GraphNodeId) => any/* Sequence<GraphEdgeId> */, edgeIds: () => any/* Sequence<GraphEdgeId> */, edge: (p0: GraphEdgeId) => ET, ends: (p0: GraphEdgeId) => any/* Sequence<GraphNodeId> */);
    get nodeIds(): () => any/* Sequence<GraphNodeId> */;
    get node(): (p0: GraphNodeId) => NT;
    get incoming(): (p0: GraphNodeId) => any/* Sequence<GraphEdgeId> */;
    get outgoing(): (p0: GraphNodeId) => any/* Sequence<GraphEdgeId> */;
    get edgeIds(): () => any/* Sequence<GraphEdgeId> */;
    get edge(): (p0: GraphEdgeId) => ET;
    get ends(): (p0: GraphEdgeId) => any/* Sequence<GraphNodeId> */;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphFunctions.$metadata$ {
    const constructor: abstract new <NT extends any, ET extends any>() => GraphFunctions<NT, ET>;
}
export declare class GraphFromFunctions<NT extends any, ET extends any> implements Graph {
    constructor(functions: GraphFunctions<NT, ET>);
    get functions(): GraphFunctions<NT, ET>;
    get nodes(): any/* Iterable<GraphNode> */;
    get edges(): any/* Iterable<GraphEdge> */;
    readonly __doNotUseOrImplementIt: Graph["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphFromFunctions.$metadata$ {
    const constructor: abstract new <NT extends any, ET extends any>() => GraphFromFunctions<NT, ET>;
}
export declare class GraphSimple implements Graph {
    constructor(graphId: string);
    get graphId(): string;
    get nodes(): KtMutableList<GraphNode>;
    get edges(): KtMutableList<GraphEdge>;
    copy(graphId?: string): GraphSimple;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Graph["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphSimple.$metadata$ {
    const constructor: abstract new () => GraphSimple;
}
export declare class GraphNodeSimple implements GraphNode {
    constructor(id: GraphNodeId);
    get id(): GraphNodeId;
    get incoming(): KtMutableList<GraphEdge>;
    get outgoing(): KtMutableList<GraphEdge>;
    copy(id?: GraphNodeId): GraphNodeSimple;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: GraphNode["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphNodeSimple.$metadata$ {
    const constructor: abstract new () => GraphNodeSimple;
}
export declare class GraphEdgeSimple implements GraphEdge {
    constructor(id: GraphEdgeId);
    get id(): GraphEdgeId;
    get ends(): KtMutableList<GraphNode>;
    copy(id?: GraphEdgeId): GraphEdgeSimple;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    get source(): GraphNode;
    get target(): GraphNode;
    readonly __doNotUseOrImplementIt: GraphEdge["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphEdgeSimple.$metadata$ {
    const constructor: abstract new () => GraphEdgeSimple;
}
export declare class ManagedReferenceCollection<T extends any> /* extends ManagedCollection<Reference<any, T>> */ {
    constructor(name: string, referenceType: any/* KClass<T> */, onAdded?: Nullable<(p0: Reference<any, T>) => void>, onRemoved?: Nullable<(p0: Reference<any, T>) => void>);
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ManagedReferenceCollection.$metadata$ {
    const constructor: abstract new <T extends any>() => ManagedReferenceCollection<T>;
}
export declare class ManagedReferenceSet<T extends any> /* extends ManagedSet<Reference<any, T>> */ implements KtMutableSet<Reference<any, T>> {
    constructor(name: string, referenceType: any/* KClass<T> */, onAdded?: Nullable<(p0: Reference<any, T>) => void>, onRemoved?: Nullable<(p0: Reference<any, T>) => void>);
    get size(): number;
    asJsSetView(): Set<Reference<any, T>>;
    asJsReadonlySetView(): ReadonlySet<Reference<any, T>>;
    readonly __doNotUseOrImplementIt: KtMutableSet<Reference<any, T>>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ManagedReferenceSet.$metadata$ {
    const constructor: abstract new <T extends any>() => ManagedReferenceSet<T>;
}
export declare class ManagedReferenceOrderedSet<T extends any> /* extends ManagedOrderedSet<Reference<any, T>> */ implements KtMutableSet<Reference<any, T>>, MutableOrderedSet<Reference<any, T>> {
    constructor(name: string, referenceType: any/* KClass<T> */, onAdded?: Nullable<(p0: Reference<any, T>) => void>, onRemoved?: Nullable<(p0: Reference<any, T>) => void>);
    get size(): number;
    get(index: number): Reference<any, T>;
    asJsSetView(): Set<Reference<any, T>>;
    asJsReadonlySetView(): ReadonlySet<Reference<any, T>>;
    readonly __doNotUseOrImplementIt: KtMutableSet<Reference<any, T>>["__doNotUseOrImplementIt"] & MutableOrderedSet<Reference<any, T>>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ManagedReferenceOrderedSet.$metadata$ {
    const constructor: abstract new <T extends any>() => ManagedReferenceOrderedSet<T>;
}
export declare abstract class ListExt {
    static readonly getInstance: () => typeof ListExt.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ListExt.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        private constructor();
    }
}
export declare abstract class SetExt {
    static readonly getInstance: () => typeof SetExt.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SetExt.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        private constructor();
    }
}
export declare abstract class OrderedSetExt {
    static readonly getInstance: () => typeof OrderedSetExt.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OrderedSetExt.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        private constructor();
    }
}
export declare function topologicalSort<E>(_this_: any/* Collection<E> */, comparator: any/* Comparator<E> */): KtList<E>;
export declare function transitveClosure<T>(_this_: KtSet<T>, _function: (p0: T) => KtSet<T>): KtSet<T>;
export declare interface Tree {
    readonly root: TreeNode;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.Tree": unique symbol;
    };
}
export declare interface TreeNode {
    readonly id: string;
    readonly children: any/* Iterable<TreeNode> */;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.collections.TreeNode": unique symbol;
    };
}
export declare class TreeFunctions<T extends any> {
    constructor(label: (p0: Nullable<any>, p1: T) => string, hasChildren: (p0: T) => boolean, children: (p0: T) => any/* Iterable<T> */);
    get label(): (p0: Nullable<any>, p1: T) => string;
    get hasChildren(): (p0: T) => boolean;
    get children(): (p0: T) => any/* Iterable<T> */;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TreeFunctions.$metadata$ {
    const constructor: abstract new <T extends any>() => TreeFunctions<T>;
}
export declare abstract class IssueKind {
    private constructor();
    static get ERROR(): IssueKind & {
        get name(): "ERROR";
        get ordinal(): 0;
    };
    static get WARNING(): IssueKind & {
        get name(): "WARNING";
        get ordinal(): 1;
    };
    static get INFORMATION(): IssueKind & {
        get name(): "INFORMATION";
        get ordinal(): 2;
    };
    get name(): "ERROR" | "WARNING" | "INFORMATION";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<IssueKind>;
    static valueOf(value: string): IssueKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IssueKind.$metadata$ {
    const constructor: abstract new () => IssueKind;
}
export declare interface Issue<L> {
    readonly kind: IssueKind;
    readonly location: Nullable<L>;
    readonly message: string;
    readonly data: Nullable<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.issues.api.Issue": unique symbol;
    };
}
export declare interface IssueCollection<L extends any> /* extends Collection<Issue<L>> */ {
    readonly all: KtSet<Issue<L>>;
    readonly errors: KtList<Issue<L>>;
    readonly warnings: KtList<Issue<L>>;
    readonly informations: KtList<Issue<L>>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.kotlinx.issues.api.IssueCollection": unique symbol;
    };
}
export declare class IssueDefault<L extends any> implements Issue<L> {
    constructor(kind: IssueKind, location: Nullable<L>, message: string, data?: Nullable<any>);
    get kind(): IssueKind;
    get location(): Nullable<L>;
    get message(): string;
    get data(): Nullable<any>;
    copy(kind?: IssueKind, location?: Nullable<L>, message?: string, data?: Nullable<any>): IssueDefault<L>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Issue<L>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IssueDefault.$metadata$ {
    const constructor: abstract new <L extends any>() => IssueDefault<L>;
}
export declare function plus<L extends any>(_this_: IssueCollection<L>, other: IssueCollection<L>): IssueHolder<L>;
export declare class IssueHolder<L extends any> implements IssueCollection<L> {
    constructor(issues?: any/* Iterable<Issue<L>> */);
    get all(): KtSet<Issue<L>>;
    get errors(): KtList<Issue<L>>;
    get warnings(): KtList<Issue<L>>;
    get informations(): KtList<Issue<L>>;
    clear(): void;
    raise(kind: IssueKind, location: Nullable<L>, message: string, data?: Nullable<any>): void;
    info(location: Nullable<L>, message: string, data?: Nullable<any>): void;
    warn(location: Nullable<L>, message: string, data?: Nullable<any>): void;
    error(location: Nullable<L>, message: string, data?: Nullable<any>): void;
    addAll(issues: any/* Iterable<Issue<L>> */): void;
    addAllFrom(other: IssueCollection<L>): void;
    toString(): string;
    readonly __doNotUseOrImplementIt: IssueCollection<L>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IssueHolder.$metadata$ {
    const constructor: abstract new <L extends any>() => IssueHolder<L>;
}
export declare abstract class BuildConfig {
    static readonly getInstance: () => typeof BuildConfig.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BuildConfig.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get version(): string;
        get buildStamp(): string;
        get buildDate(): string;
        get buildTime(): string;
        private constructor();
    }
}
export declare function regexMatcher(pattern: string): RegexMatcher;
export declare class RegexParser {
    constructor();
    parse(pattern: string): RegexMatcher;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexParser.$metadata$ {
    const constructor: abstract new () => RegexParser;
}
export declare class RegexValueProvider {
    constructor(pattern: string, anyChar: any/* Char */);
    get anyChar(): any/* Char */;
    get matcher(): RegexMatcher;
    provide(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexValueProvider.$metadata$ {
    const constructor: abstract new () => RegexValueProvider;
}
export declare namespace RegexValueProvider {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get PRINTABLE_ASCII(): KtList<any/* Char */>;
            private constructor();
        }
    }
}
export declare abstract class RegexEngineKind {
    private constructor();
    static get PLATFORM(): RegexEngineKind & {
        get name(): "PLATFORM";
        get ordinal(): 0;
    };
    static get AGL(): RegexEngineKind & {
        get name(): "AGL";
        get ordinal(): 1;
    };
    get name(): "PLATFORM" | "AGL";
    get ordinal(): 0 | 1;
    static values(): Array<RegexEngineKind>;
    static valueOf(value: string): RegexEngineKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexEngineKind.$metadata$ {
    const constructor: abstract new () => RegexEngineKind;
}
export declare interface RegexMatcher {
    match(text: any/* CharSequence */, startPosition?: number): Nullable<MatchResult>;
    matchAt(text: string, atPosition: number): Nullable<MatchResult>;
    matchesAt(text: string, atPosition: number): boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.regex.api.RegexMatcher": unique symbol;
    };
}
export declare interface Regex {
    matchesAt(text: string, atPosition: number): boolean;
    matchAt(text: string, atPosition: number): Nullable<MatchResult>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.regex.api.Regex": unique symbol;
    };
}
export declare interface RegexEngine {
    readonly kind: RegexEngineKind;
    createFor(pattern: string): Regex;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.regex.api.RegexEngine": unique symbol;
    };
}
export declare interface MatchResult {
    readonly matchedText: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.regex.api.MatchResult": unique symbol;
    };
}
export declare interface EscapedValue {
    readonly value: string;
    readonly unescapedFromAgl: UnescapedValue;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.regex.api.EscapedValue": unique symbol;
    };
}
export declare interface UnescapedValue {
    readonly value: string;
    readonly escapedFoAgl: EscapedValue;
    readonly escapedForRegex: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.regex.api.UnescapedValue": unique symbol;
    };
}
export declare class EscapedPattern implements EscapedValue {
    constructor(value: string);
    get value(): string;
    get unescapedFromAgl(): UnescapedValue;
    copy(value?: string): EscapedPattern;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: EscapedValue["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EscapedPattern.$metadata$ {
    const constructor: abstract new () => EscapedPattern;
}
export declare class UnescapedPattern implements UnescapedValue {
    constructor(value: string);
    get value(): string;
    get escapedFoAgl(): EscapedPattern;
    get escapedForRegex(): string;
    toRegex(): any/* Regex */;
    copy(value?: string): UnescapedPattern;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: UnescapedValue["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace UnescapedPattern.$metadata$ {
    const constructor: abstract new () => UnescapedPattern;
}
export declare class EscapedLiteral implements EscapedValue {
    constructor(value: string);
    get value(): string;
    get unescapedFromAgl(): UnescapedValue;
    copy(value?: string): EscapedLiteral;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: EscapedValue["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EscapedLiteral.$metadata$ {
    const constructor: abstract new () => EscapedLiteral;
}
export declare class UnescapedLiteral implements UnescapedValue {
    constructor(value: string);
    get value(): string;
    get escapedFoAgl(): EscapedLiteral;
    get escapedForRegex(): string;
    copy(value?: string): UnescapedLiteral;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: UnescapedValue["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace UnescapedLiteral.$metadata$ {
    const constructor: abstract new () => UnescapedLiteral;
}
export declare abstract class CommonRegexPatterns {
    static readonly getInstance: () => typeof CommonRegexPatterns.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CommonRegexPatterns.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get PATTERN(): UnescapedPattern;
        unescape_PATTERN(escaped: string): UnescapedPattern;
        escape_PATTERN(unescaped: string): EscapedPattern;
        get LITERAL(): UnescapedPattern;
        unescape_LITERAL(escaped: string): UnescapedLiteral;
        escape_LITERAL(unescaped: string): EscapedLiteral;
        private constructor();
    }
}
export declare class RegexPlatform implements Regex {
    constructor(value: any/* Regex */);
    get value(): any/* Regex */;
    matchAt(text: string, atPosition: number): Nullable<MatchResult>;
    matchesAt(text: string, atPosition: number): boolean;
    copy(value?: any/* Regex */): RegexPlatform;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Regex["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexPlatform.$metadata$ {
    const constructor: abstract new () => RegexPlatform;
}
export declare class RegexAgl implements Regex {
    constructor(value: RegexMatcher);
    get value(): RegexMatcher;
    matchAt(text: string, atPosition: number): Nullable<RegexMatcher.MatchResultAgl>;
    matchesAt(text: string, atPosition: number): boolean;
    copy(value?: RegexMatcher): RegexAgl;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Regex["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexAgl.$metadata$ {
    const constructor: abstract new () => RegexAgl;
}
export declare abstract class RegexEnginePlatform {
    static readonly getInstance: () => typeof RegexEnginePlatform.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexEnginePlatform.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements RegexEngine {
        get kind(): RegexEngineKind;
        createFor(pattern: string): Regex;
        readonly __doNotUseOrImplementIt: RegexEngine["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare abstract class RegexEngineAgl {
    static readonly getInstance: () => typeof RegexEngineAgl.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RegexEngineAgl.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements RegexEngine {
        get kind(): RegexEngineKind;
        createFor(pattern: string): Regex;
        readonly __doNotUseOrImplementIt: RegexEngine["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare abstract class BuildConfig {
    static readonly getInstance: () => typeof BuildConfig.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BuildConfig.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get version(): string;
        get buildStamp(): string;
        get buildDate(): string;
        get buildTime(): string;
        private constructor();
    }
}
export declare class AutomatonForMinimal {
    constructor(runtimeRuleSet: RuntimeRuleSet, userGoalRule: RuntimeRule);
    get runtimeRuleSet(): RuntimeRuleSet;
    get userGoalRule(): RuntimeRule;
    get number(): number;
    get states(): any/* MutableCollection<StateForMinimal> */;
    get goalRule(): Rule;
    get startState(): StateForMinimal;
    get usedRules(): KtSet<RuntimeRule>;
    get usedTerminals(): KtSet<RuntimeRule>;
    createState(rp: RulePositionRuntime): StateForMinimal;
    usedAutomatonToString(withStates?: boolean): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AutomatonForMinimal.$metadata$ {
    const constructor: abstract new () => AutomatonForMinimal;
}
export declare namespace AutomatonForMinimal {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get nextNumber(): number;
            set nextNumber(value: number);
            merge(trans: KtSet<TransitionForMinimal>): KtSet<TransitionForMinimal>;
            private constructor();
        }
    }
}
export declare class StateForMinimal {
    constructor(automaton: AutomatonForMinimal, number: number, rp: RulePositionRuntime);
    get automaton(): AutomatonForMinimal;
    get number(): number;
    get rp(): RulePositionRuntime;
    get outCompleteTransitionsByCtx(): KtMutableMap<any/* Pair<StateForMinimal, StateForMinimal> */, KtSet<TransitionForMinimal>>;
    get outIncompleteTransitionsByCtx(): KtMutableMap<StateForMinimal, KtSet<TransitionForMinimal>>;
    get allOutTransition(): KtSet<TransitionForMinimal>;
    outCompleteTransForCtx(key: any/* Pair<StateForMinimal, StateForMinimal> */): Nullable<KtSet<TransitionForMinimal>>;
    outIncompleteTransForCtx(ctx: StateForMinimal): Nullable<KtSet<TransitionForMinimal>>;
    addOutCompleteTrans(key: any/* Pair<StateForMinimal, StateForMinimal> */, trans: KtSet<TransitionForMinimal>): void;
    addOutIncompleteTrans(key: StateForMinimal, trans: KtSet<TransitionForMinimal>): void;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StateForMinimal.$metadata$ {
    const constructor: abstract new () => StateForMinimal;
}
export declare class TransitionForMinimal {
    constructor(source: StateForMinimal, target: StateForMinimal, action: ParseAction, lh: LookaheadSetPart, up: LookaheadSetPart);
    get source(): StateForMinimal;
    get target(): StateForMinimal;
    get action(): ParseAction;
    get lh(): LookaheadSetPart;
    get up(): LookaheadSetPart;
    get context(): KtSet<StateForMinimal>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    copy(source?: StateForMinimal, target?: StateForMinimal, action?: ParseAction, lh?: LookaheadSetPart, up?: LookaheadSetPart): TransitionForMinimal;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TransitionForMinimal.$metadata$ {
    const constructor: abstract new () => TransitionForMinimal;
}
export declare class GSSNodeForMinimal {
    constructor(state: StateForMinimal, rlh: LookaheadSetPart, sp: number, nip: number);
    get state(): StateForMinimal;
    get rlh(): LookaheadSetPart;
    get sp(): number;
    get nip(): number;
    get nibs(): number;
    set nibs(value: number);
    get isGoal(): boolean;
    get isComplete(): boolean;
    get isEmptyMatch(): boolean;
    copy(state?: StateForMinimal, rlh?: LookaheadSetPart, sp?: number, nip?: number): GSSNodeForMinimal;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GSSNodeForMinimal.$metadata$ {
    const constructor: abstract new () => GSSNodeForMinimal;
}
export declare class CompleteNodeForMinimal implements SpptDataNode {
    constructor(rule: RuntimeRule, startPosition: number, nextInputPosition: number, nextInputNoSkip: number, option: OptionNum, dynamicPriority: KtList<number>);
    get rule(): RuntimeRule;
    get startPosition(): number;
    get nextInputPosition(): number;
    get nextInputNoSkip(): number;
    get option(): OptionNum;
    get dynamicPriority(): KtList<number>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: SpptDataNode["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompleteNodeForMinimal.$metadata$ {
    const constructor: abstract new () => CompleteNodeForMinimal;
}
export declare class MinimalParser {
    private constructor();
    get automaton(): AutomatonForMinimal;
    get isSkip(): boolean;
    get skipAutomaton(): Nullable<AutomatonForMinimal>;
    get ss(): StateForMinimal;
    get sppf(): TreeDataGrowing<GSSNodeForMinimal, CompleteNodeForMinimal>;
    set sppf(value: TreeDataGrowing<GSSNodeForMinimal, CompleteNodeForMinimal>);
    get gss(): GraphStructuredStack<GSSNodeForMinimal>;
    get skipTerms(): KtSet<RuntimeRule>;
    get skipParser(): Nullable<MinimalParser>;
    get embedded(): KtMutableMap<any/* Pair<RuntimeRuleSet, RuntimeRule> */, MinimalParser>;
    get sentence(): Nullable<Sentence>;
    set sentence(value: Nullable<Sentence>);
    get scanner(): ScannerOnDemand;
    parse(sentenceText: string): TreeData;
    reset(): void;
    clearCache(): void;
    cachePossibleContext(rp: RulePositionRuntime, ctx: RulePositionRuntime): void;
    cacheFirstTerminalInContext(ctx: RulePositionRuntime, rp: RulePositionRuntime, fti: FirstTerminalInfo): void;
    cacheParentInContext(ctx: RulePositionRuntime, cr: RuntimeRule, pn: KtSet<ParentNext>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MinimalParser.$metadata$ {
    const constructor: abstract new () => MinimalParser;
}
export declare namespace MinimalParser {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get TRACE(): boolean;
            parser(goalRuleName: string, runtimeRuleSet: RuntimeRuleSet): MinimalParser;
            setFirstChildForParent(_this_: TreeDataGrowing<GSSNodeForMinimal, CompleteNodeForMinimal>, parent: GSSNodeForMinimal, child: CompleteNodeForMinimal): void;
            private constructor();
        }
    }
}
export declare abstract class AutomatonKind {
    private constructor();
    static get LOOKAHEAD_NONE(): AutomatonKind & {
        get name(): "LOOKAHEAD_NONE";
        get ordinal(): 0;
    };
    static get LOOKAHEAD_SIMPLE(): AutomatonKind & {
        get name(): "LOOKAHEAD_SIMPLE";
        get ordinal(): 1;
    };
    static get LOOKAHEAD_1(): AutomatonKind & {
        get name(): "LOOKAHEAD_1";
        get ordinal(): 2;
    };
    get name(): "LOOKAHEAD_NONE" | "LOOKAHEAD_SIMPLE" | "LOOKAHEAD_1";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<AutomatonKind>;
    static valueOf(value: string): AutomatonKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AutomatonKind.$metadata$ {
    const constructor: abstract new () => AutomatonKind;
}
export declare class StateNumber {
    constructor(value: number);
    get value(): number;
    copy(value?: number): StateNumber;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StateNumber.$metadata$ {
    const constructor: abstract new () => StateNumber;
}
export declare interface Automaton {
    readonly ruleSet: RuleSet;
    readonly state: KtSet<AutomatonState>;
    readonly transition: KtSet<AutomatonTransition>;
    asString(withStates?: boolean): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.Automaton": unique symbol;
    };
}
export declare interface AutomatonState {
    readonly number: StateNumber;
    readonly rulePosition: KtList<RulePosition>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.AutomatonState": unique symbol;
    };
}
export declare interface AutomatonTransition {
    readonly action: ParseAction;
    readonly source: AutomatonState;
    readonly target: AutomatonState;
    readonly lookahead: KtSet<LookaheadGuard>;
    readonly prev: KtSet<AutomatonState>;
    readonly prevPrev: KtSet<AutomatonState>;
    readonly transContext: KtSet<TransitionContext>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.AutomatonTransition": unique symbol;
    };
}
export declare interface TransitionContext {
    readonly prevPrev: AutomatonState;
    readonly prev: AutomatonState;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.TransitionContext": unique symbol;
    };
}
export declare interface LookaheadGuard {
    readonly guard: KtSet<Rule>;
    readonly up: KtSet<Rule>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.LookaheadGuard": unique symbol;
    };
}
export declare abstract class ParseAction {
    private constructor();
    static get HEIGHT(): ParseAction & {
        get name(): "HEIGHT";
        get ordinal(): 0;
    };
    static get GRAFT(): ParseAction & {
        get name(): "GRAFT";
        get ordinal(): 1;
    };
    static get WIDTH(): ParseAction & {
        get name(): "WIDTH";
        get ordinal(): 2;
    };
    static get GOAL(): ParseAction & {
        get name(): "GOAL";
        get ordinal(): 3;
    };
    static get EMBED(): ParseAction & {
        get name(): "EMBED";
        get ordinal(): 4;
    };
    get name(): "HEIGHT" | "GRAFT" | "WIDTH" | "GOAL" | "EMBED";
    get ordinal(): 0 | 1 | 2 | 3 | 4;
    static values(): Array<ParseAction>;
    static valueOf(value: string): ParseAction;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParseAction.$metadata$ {
    const constructor: abstract new () => ParseAction;
}
export declare interface AutomatonBuilder {
    state(ruleNumber: number, option: OptionNum, position: number): void;
    transition(action: ParseAction, init: (p0: TransitionBuilder) => void): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.AutomatonBuilder": unique symbol;
    };
}
export declare interface TransitionBuilder {
    pctx(stateNumbers: Int32Array): void;
    ctx(stateNumbers: Int32Array): void;
    src(stateNumber: number): void;
    tgt(stateNumber: number): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.api.TransitionBuilder": unique symbol;
    };
}
export declare function aut(rrs: RuleSet, automatonKind: AutomatonKind, userGoalRule: string, isSkip: boolean, init: (p0: AutomatonBuilder) => void): Automaton;
export declare class Lookahead implements LookaheadGuard {
    constructor(guardLookaheadSet: any/* LookaheadSet */, upLookaheadSet: any/* LookaheadSet */);
    get guardLookaheadSet(): any/* LookaheadSet */;
    get upLookaheadSet(): any/* LookaheadSet */;
    get guard(): KtSet<RuntimeRule>;
    get up(): KtSet<RuntimeRule>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: LookaheadGuard["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Lookahead.$metadata$ {
    const constructor: abstract new () => Lookahead;
}
export declare namespace Lookahead {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get EMPTY(): Lookahead;
            merge(automaton: ParserStateSet, initial: KtSet<Lookahead>): KtSet<Lookahead>;
            private constructor();
        }
    }
}
export declare class ParserState implements AutomatonState {
    constructor(number: StateNumber, rulePosition: KtList<RulePositionRuntime>, stateSet: ParserStateSet);
    get number(): StateNumber;
    get rulePosition(): KtList<RulePositionRuntime>;
    get stateSet(): ParserStateSet;
    get outTransitions(): TransitionCache;
    get runtimeRules(): KtList<RuntimeRule>;
    get runtimeRulesAsSet(): KtSet<RuntimeRule>;
    get optionList(): KtList<OptionNum>;
    get priorityList(): KtList<number>;
    get isChoice(): boolean;
    get isOptional(): boolean;
    get isList(): boolean;
    get firstRule(): RuntimeRule;
    get isLeaf(): boolean;
    get isAtEnd(): boolean;
    get isNotAtEnd(): boolean;
    get isGoal(): boolean;
    transitionsGoal(previous: ParserState): KtList<Transition>;
    transitionsInComplete(previous: ParserState): KtList<Transition>;
    transitionsComplete(previous: ParserState, prevPrev: ParserState): KtList<Transition>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AutomatonState["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParserState.$metadata$ {
    const constructor: abstract new () => ParserState;
}
export declare namespace ParserState {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            lhs(_this_: LookaheadSetPart, stateSet: ParserStateSet): any/* LookaheadSet */;
            private constructor();
        }
    }
}
export declare class ParserStateSet implements Automaton {
    constructor(number: number, runtimeRuleSet: RuntimeRuleSet, userGoalRule: RuntimeRule, isSkip: boolean, automatonKind: AutomatonKind, preBuilt: boolean);
    get number(): number;
    get runtimeRuleSet(): RuntimeRuleSet;
    get userGoalRule(): RuntimeRule;
    get isSkip(): boolean;
    get automatonKind(): AutomatonKind;
    get preBuilt(): boolean;
    set preBuilt(value: boolean);
    get usedRules(): KtSet<RuntimeRule>;
    get usedTerminalRules(): KtSet<RuntimeRule>;
    get usedNonTerminalRules(): KtSet<RuntimeRule>;
    get firstTerminals(): KtSet<RuntimeRule>;
    get embeddedRuntimeRuleSet(): KtSet<RuntimeRuleSet>;
    get allBuiltStates(): KtList<ParserState>;
    get allBuiltTransitions(): KtSet<Transition>;
    get goalRule(): Rule;
    get startRulePosition(): RulePositionRuntime;
    get finishRulePosition(): RulePositionRuntime;
    get startState(): ParserState;
    get finishState(): ParserState;
    precedenceRulesFor(sourceState: ParserState): Nullable<RuntimePreferenceRule>;
    build(): ParserStateSet;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    usedAutomatonToString(withStates?: boolean): string;
    toString(): string;
    get ruleSet(): RuleSet;
    get state(): KtSet<AutomatonState>;
    get transition(): KtSet<AutomatonTransition>;
    asString(withStates?: boolean): string;
    readonly __doNotUseOrImplementIt: Automaton["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParserStateSet.$metadata$ {
    const constructor: abstract new () => ParserStateSet;
}
export declare interface RuntimeGuard {
    execute(numNonSkipChildren: number): boolean;
    expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.leftcorner.RuntimeGuard": unique symbol;
    };
}
export declare class Transition implements AutomatonTransition {
    constructor(source: ParserState, target: ParserState, action: ParseAction, lookaheadGuard: KtSet<Lookahead>);
    get source(): ParserState;
    get target(): ParserState;
    get action(): ParseAction;
    get lookaheadGuard(): KtSet<Lookahead>;
    get context(): KtSet<TransitionPrevInfoKey>;
    get runtimeGuard(): RuntimeGuard;
    get lookahead(): KtSet<LookaheadGuard>;
    get prev(): KtSet<AutomatonState>;
    get prevPrev(): KtSet<AutomatonState>;
    get transContext(): KtSet<TransitionContext>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AutomatonTransition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Transition.$metadata$ {
    const constructor: abstract new () => Transition;
}
export declare namespace Transition {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        namespace type {
            class ToEndMultiGraftRuntimeGuard implements RuntimeGuard {
                constructor(trans: Transition);
                get trans(): Transition;
                get rhs(): RuntimeRuleRhsListSimple;
                get min(): number;
                get max(): number;
                execute(numNonSkipChildren: number): boolean;
                expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
                toString(): string;
                readonly __doNotUseOrImplementIt: RuntimeGuard["__doNotUseOrImplementIt"];
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace ToEndMultiGraftRuntimeGuard.$metadata$ {
                const constructor: abstract new () => ToEndMultiGraftRuntimeGuard;
            }
            class ToItemMultiGraftRuntimeGuard implements RuntimeGuard {
                constructor(trans: Transition);
                get trans(): Transition;
                get rhs(): RuntimeRuleRhsListSimple;
                get min(): number;
                get max(): number;
                execute(numNonSkipChildren: number): boolean;
                expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
                toString(): string;
                readonly __doNotUseOrImplementIt: RuntimeGuard["__doNotUseOrImplementIt"];
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace ToItemMultiGraftRuntimeGuard.$metadata$ {
                const constructor: abstract new () => ToItemMultiGraftRuntimeGuard;
            }
            class ToEndSListGraftRuntimeGuard implements RuntimeGuard {
                constructor(trans: Transition);
                get trans(): Transition;
                get rhs(): RuntimeRuleRhsList;
                get min(): number;
                get max(): number;
                execute(numNonSkipChildren: number): boolean;
                expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
                toString(): string;
                readonly __doNotUseOrImplementIt: RuntimeGuard["__doNotUseOrImplementIt"];
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace ToEndSListGraftRuntimeGuard.$metadata$ {
                const constructor: abstract new () => ToEndSListGraftRuntimeGuard;
            }
            class ToItemSListGraftRuntimeGuard implements RuntimeGuard {
                constructor(trans: Transition);
                get trans(): Transition;
                get rhs(): RuntimeRuleRhsList;
                get min(): number;
                get max(): number;
                execute(numNonSkipChildren: number): boolean;
                expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
                toString(): string;
                readonly __doNotUseOrImplementIt: RuntimeGuard["__doNotUseOrImplementIt"];
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace ToItemSListGraftRuntimeGuard.$metadata$ {
                const constructor: abstract new () => ToItemSListGraftRuntimeGuard;
            }
            class ToSeparatorSListGraftRuntimeGuard implements RuntimeGuard {
                constructor(trans: Transition);
                get trans(): Transition;
                get rhs(): RuntimeRuleRhsList;
                get min(): number;
                get max(): number;
                execute(numNonSkipChildren: number): boolean;
                expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
                toString(): string;
                readonly __doNotUseOrImplementIt: RuntimeGuard["__doNotUseOrImplementIt"];
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace ToSeparatorSListGraftRuntimeGuard.$metadata$ {
                const constructor: abstract new () => ToSeparatorSListGraftRuntimeGuard;
            }
            abstract class DefaultRuntimeGuard {
                static readonly getInstance: () => typeof DefaultRuntimeGuard.$metadata$.type;
                private constructor();
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace DefaultRuntimeGuard.$metadata$ {
                abstract class type extends KtSingleton<constructor>() {
                    private constructor();
                }
                abstract class constructor implements RuntimeGuard {
                    execute(numNonSkipChildren: number): boolean;
                    expectedWhenFailed(numNonSkipChildren: number): KtSet<RuntimeRule>;
                    toString(): string;
                    readonly __doNotUseOrImplementIt: RuntimeGuard["__doNotUseOrImplementIt"];
                    private constructor();
                }
            }
        }
        abstract class constructor {
            runtimeGuardFor(trans: Transition): RuntimeGuard;
            private constructor();
        }
    }
}
export declare interface TransitionCache {
    readonly allBuiltTransitions: KtSet<Transition>;
    readonly allPrevious: KtSet<TransitionPrevInfoKey>;
    createTransitionForComplete(previous: ParserState, prevPrev: ParserState, from: ParserState, action: ParseAction, to: ParserState, lookahead: KtSet<Lookahead>): void;
    createTransitionForIncomplete(previous: ParserState, from: ParserState, action: ParseAction, to: ParserState, lookahead: KtSet<Lookahead>): void;
    addTransitionForIncomplete(previous: ParserState, tr: Transition): Transition;
    addTransitionForComplete(previous: ParserState, prevPrev: ParserState, tr: Transition): Transition;
    findTransitionForCompleteByPrevious(previous: ParserState, prevPrev: ParserState): Nullable<KtList<Transition>>;
    findTransitionForIncompleteByPrevious(previous: ParserState): Nullable<KtList<Transition>>;
    findTransitionByKey(key: TransitionPrevInfoKey): Nullable<KtList<Transition>>;
    previousFor(transition: Transition): KtList<TransitionPrevInfoKey>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.leftcorner.TransitionCache": unique symbol;
    };
}
export declare interface TransitionPrevInfoKey {
    readonly previous: ParserState;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.automaton.leftcorner.TransitionPrevInfoKey": unique symbol;
    };
}
export declare class CompleteKey implements TransitionPrevInfoKey, TransitionContext {
    constructor(previous: ParserState, prevPrev: ParserState);
    get previous(): ParserState;
    get prevPrev(): ParserState;
    get prev(): ParserState;
    toString(): string;
    copy(previous?: ParserState, prevPrev?: ParserState): CompleteKey;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: TransitionPrevInfoKey["__doNotUseOrImplementIt"] & TransitionContext["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompleteKey.$metadata$ {
    const constructor: abstract new () => CompleteKey;
}
export declare class IncompleteKey implements TransitionPrevInfoKey {
    constructor(previous: ParserState);
    get previous(): ParserState;
    toString(): string;
    copy(previous?: ParserState): IncompleteKey;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: TransitionPrevInfoKey["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IncompleteKey.$metadata$ {
    const constructor: abstract new () => IncompleteKey;
}
export declare class TransitionCacheLC1 implements TransitionCache {
    constructor();
    get allBuiltTransitions(): KtSet<Transition>;
    get allPrevious(): KtSet<TransitionPrevInfoKey>;
    addTransitionForComplete(previous: ParserState, prevPrev: ParserState, tr: Transition): Transition;
    addTransitionForIncomplete(previous: ParserState, tr: Transition): Transition;
    findTransitionForCompleteByPrevious(previous: ParserState, prevPrev: ParserState): Nullable<KtList<Transition>>;
    findTransitionForIncompleteByPrevious(previous: ParserState): Nullable<KtList<Transition>>;
    findTransitionByKey(key: TransitionPrevInfoKey): Nullable<KtList<Transition>>;
    previousFor(transition: Transition): KtList<TransitionPrevInfoKey>;
    createTransitionForComplete(previous: ParserState, prevPrev: ParserState, from: ParserState, action: ParseAction, to: ParserState, lookahead: KtSet<Lookahead>): void;
    createTransitionForIncomplete(previous: ParserState, from: ParserState, action: ParseAction, to: ParserState, lookahead: KtSet<Lookahead>): void;
    readonly __doNotUseOrImplementIt: TransitionCache["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TransitionCacheLC1.$metadata$ {
    const constructor: abstract new () => TransitionCacheLC1;
}
export declare namespace TransitionCacheLC1 {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class LookaheadSetPart {
    constructor(includesRT: boolean, includesEOT: boolean, matchANY: boolean, content: KtSet<RuntimeRule>);
    get includesRT(): boolean;
    get includesEOT(): boolean;
    get matchANY(): boolean;
    get content(): KtSet<RuntimeRule>;
    get regex(): any/* Regex */;
    get fullContent(): KtSet<RuntimeRule>;
    get isEmpty(): boolean;
    get isNotEmpty(): boolean;
    resolve(eotLookahead: LookaheadSetPart, runtimeLookahead: LookaheadSetPart): LookaheadSetPart;
    intersect(lookahead: LookaheadSetPart): LookaheadSetPart;
    union(lhs: LookaheadSetPart): LookaheadSetPart;
    unionContent(additionalContent: KtSet<RuntimeRule>): LookaheadSetPart;
    containsAll(other: LookaheadSetPart): boolean;
    toString(): string;
    copy(includesRT?: boolean, includesEOT?: boolean, matchANY?: boolean, content?: KtSet<RuntimeRule>): LookaheadSetPart;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LookaheadSetPart.$metadata$ {
    const constructor: abstract new () => LookaheadSetPart;
}
export declare namespace LookaheadSetPart {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get EMPTY(): LookaheadSetPart;
            get RT(): LookaheadSetPart;
            get ANY(): LookaheadSetPart;
            get EOT(): LookaheadSetPart;
            createFromRuntimeRules(fullContent: KtSet<RuntimeRule>): LookaheadSetPart;
            unionAll(_this_: any/* Collection<LookaheadSetPart> */): LookaheadSetPart;
            private constructor();
        }
    }
}
export declare class FirstTerminalInfo {
    constructor(terminalRule: RuntimeRule, parentExpectedAt: LookaheadSetPart);
    get terminalRule(): RuntimeRule;
    get parentExpectedAt(): LookaheadSetPart;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    copy(terminalRule?: RuntimeRule, parentExpectedAt?: LookaheadSetPart): FirstTerminalInfo;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FirstTerminalInfo.$metadata$ {
    const constructor: abstract new () => FirstTerminalInfo;
}
export declare class ParentNext {
    constructor(firstPosition: boolean, rulePosition: RulePositionRuntime, expectedAt: LookaheadSetPart, parentExpectedAt: LookaheadSetPart);
    get firstPosition(): boolean;
    get rulePosition(): RulePositionRuntime;
    get expectedAt(): LookaheadSetPart;
    get parentExpectedAt(): LookaheadSetPart;
    copy(firstPosition?: boolean, rulePosition?: RulePositionRuntime, expectedAt?: LookaheadSetPart, parentExpectedAt?: LookaheadSetPart): ParentNext;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParentNext.$metadata$ {
    const constructor: abstract new () => ParentNext;
}
export declare abstract class LanguageIssueKind {
    private constructor();
    static get ERROR(): LanguageIssueKind & {
        get name(): "ERROR";
        get ordinal(): 0;
    };
    static get WARNING(): LanguageIssueKind & {
        get name(): "WARNING";
        get ordinal(): 1;
    };
    static get INFORMATION(): LanguageIssueKind & {
        get name(): "INFORMATION";
        get ordinal(): 2;
    };
    get name(): "ERROR" | "WARNING" | "INFORMATION";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<LanguageIssueKind>;
    static valueOf(value: string): LanguageIssueKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageIssueKind.$metadata$ {
    const constructor: abstract new () => LanguageIssueKind;
}
export declare abstract class LanguageProcessorPhase {
    private constructor();
    static get GRAMMAR(): LanguageProcessorPhase & {
        get name(): "GRAMMAR";
        get ordinal(): 0;
    };
    static get SCAN(): LanguageProcessorPhase & {
        get name(): "SCAN";
        get ordinal(): 1;
    };
    static get PARSE(): LanguageProcessorPhase & {
        get name(): "PARSE";
        get ordinal(): 2;
    };
    static get SYNTAX_ANALYSIS(): LanguageProcessorPhase & {
        get name(): "SYNTAX_ANALYSIS";
        get ordinal(): 3;
    };
    static get SEMANTIC_ANALYSIS(): LanguageProcessorPhase & {
        get name(): "SEMANTIC_ANALYSIS";
        get ordinal(): 4;
    };
    static get INTERPRET(): LanguageProcessorPhase & {
        get name(): "INTERPRET";
        get ordinal(): 5;
    };
    static get GENERATE(): LanguageProcessorPhase & {
        get name(): "GENERATE";
        get ordinal(): 6;
    };
    static get FORMAT(): LanguageProcessorPhase & {
        get name(): "FORMAT";
        get ordinal(): 7;
    };
    static get ALL(): LanguageProcessorPhase & {
        get name(): "ALL";
        get ordinal(): 8;
    };
    get name(): "GRAMMAR" | "SCAN" | "PARSE" | "SYNTAX_ANALYSIS" | "SEMANTIC_ANALYSIS" | "INTERPRET" | "GENERATE" | "FORMAT" | "ALL";
    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
    static values(): Array<LanguageProcessorPhase>;
    static valueOf(value: string): LanguageProcessorPhase;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageProcessorPhase.$metadata$ {
    const constructor: abstract new () => LanguageProcessorPhase;
}
export declare class LanguageIssue {
    constructor(kind: LanguageIssueKind, phase: LanguageProcessorPhase, location: Nullable<InputLocation>, message: string, data?: Nullable<any>);
    get kind(): LanguageIssueKind;
    get phase(): LanguageProcessorPhase;
    get location(): Nullable<InputLocation>;
    get message(): string;
    get data(): Nullable<any>;
    copy(kind?: LanguageIssueKind, phase?: LanguageProcessorPhase, location?: Nullable<InputLocation>, message?: string, data?: Nullable<any>): LanguageIssue;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageIssue.$metadata$ {
    const constructor: abstract new () => LanguageIssue;
}
export declare interface IssueCollection<T extends any> /* extends Collection<T> */ {
    readonly all: KtSet<T>;
    readonly errors: KtList<T>;
    readonly warnings: KtList<T>;
    readonly informations: KtList<T>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.issues.api.IssueCollection": unique symbol;
    };
}
export declare function plus(_this_: IssueCollection<LanguageIssue>, other: IssueCollection<LanguageIssue>): IssueHolder;
export declare class IssueHolder implements IssueCollection<LanguageIssue> {
    constructor(defaultPhase?: LanguageProcessorPhase, issues?: any/* Iterable<LanguageIssue> */);
    get all(): KtSet<LanguageIssue>;
    get errors(): KtList<LanguageIssue>;
    get warnings(): KtList<LanguageIssue>;
    get informations(): KtList<LanguageIssue>;
    clear(): void;
    raise(kind: LanguageIssueKind, phase: LanguageProcessorPhase, location: Nullable<InputLocation>, message: string, data?: Nullable<any>): void;
    info(location: Nullable<InputLocation>, message: string, data?: Nullable<any>): void;
    warn(location: Nullable<InputLocation>, message: string, data?: Nullable<any>): void;
    error(location: Nullable<InputLocation>, message: string, data?: Nullable<any>): void;
    addAll(issues: any/* Iterable<LanguageIssue> */): void;
    addAllFrom(other: IssueCollection<LanguageIssue>): void;
    toString(): string;
    readonly __doNotUseOrImplementIt: IssueCollection<LanguageIssue>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IssueHolder.$metadata$ {
    const constructor: abstract new () => IssueHolder;
}
export declare abstract class SentenceIdentityFunctionNull {
    static readonly getInstance: () => typeof SentenceIdentityFunctionNull.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SentenceIdentityFunctionNull.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements SentenceIdentityFunction {
        invoke(): Nullable<any>;
        readonly __doNotUseOrImplementIt: SentenceIdentityFunction["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare class ParseOptionsDefault implements ParseOptions {
    constructor(enabled?: boolean, goalRuleName?: Nullable<string>, sentenceIdentity?: SentenceIdentityFunction, reportErrors?: boolean, reportGrammarAmbiguities?: boolean, cacheSkip?: boolean, reverseFindWordStartRegex?: Nullable<string>, reverseFindWordStartBySkipRules?: boolean);
    get enabled(): boolean;
    set enabled(value: boolean);
    get goalRuleName(): Nullable<string>;
    set goalRuleName(value: Nullable<string>);
    get sentenceIdentity(): SentenceIdentityFunction;
    set sentenceIdentity(value: SentenceIdentityFunction);
    get reportErrors(): boolean;
    set reportErrors(value: boolean);
    get reportGrammarAmbiguities(): boolean;
    set reportGrammarAmbiguities(value: boolean);
    get cacheSkip(): boolean;
    set cacheSkip(value: boolean);
    get reverseFindWordStartRegex(): Nullable<string>;
    set reverseFindWordStartRegex(value: Nullable<string>);
    get reverseFindWordStartBySkipRules(): boolean;
    set reverseFindWordStartBySkipRules(value: boolean);
    clone(): ParseOptionsDefault;
    readonly __doNotUseOrImplementIt: ParseOptions["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParseOptionsDefault.$metadata$ {
    const constructor: abstract new () => ParseOptionsDefault;
}
export declare class ParseResultDefault implements ParseResult {
    constructor(sppt: Nullable<SharedPackedParseTree>, issues: IssueCollection<LanguageIssue>);
    get sppt(): Nullable<SharedPackedParseTree>;
    get issues(): IssueCollection<LanguageIssue>;
    copy(sppt?: Nullable<SharedPackedParseTree>, issues?: IssueCollection<LanguageIssue>): ParseResultDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ParseResult["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParseResultDefault.$metadata$ {
    const constructor: abstract new () => ParseResultDefault;
}
export declare class ParseFailureRuntime implements ParseFailure {
    constructor(failedSpines: KtList<RuntimeSpine>);
    get failedSpines(): KtList<RuntimeSpine>;
    get expectedTerminals(): KtSet<Rule>;
    get expected(): KtSet<string>;
    message(sentence: Sentence, location: InputLocation): string;
    copy(failedSpines?: KtList<RuntimeSpine>): ParseFailureRuntime;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ParseFailure["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParseFailureRuntime.$metadata$ {
    const constructor: abstract new () => ParseFailureRuntime;
}
export declare class ExpectedAtResultDefault implements ExpectedAtResult {
    constructor(usedPosition: number, spines: KtSet<RuntimeSpine>);
    get usedPosition(): number;
    get spines(): KtSet<RuntimeSpine>;
    copy(usedPosition?: number, spines?: KtSet<RuntimeSpine>): ExpectedAtResultDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ExpectedAtResult["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpectedAtResultDefault.$metadata$ {
    const constructor: abstract new () => ExpectedAtResultDefault;
}
export declare class LeftCornerParser implements Parser {
    constructor(scanner: Scanner, ruleSet: RuleSet);
    get scanner(): Scanner;
    get automatonKind(): AutomatonKind;
    get ruleSet(): RuleSet;
    get runtimeDataIsEmpty(): boolean;
    reset(): void;
    interrupt(message: string): void;
    buildFor(goalRuleName: string): void;
    parseForGoal(goalRuleName: string, sentenceText: string): ParseResult;
    parse(sentenceText: string, options: ParseOptions): ParseResult;
    expectedAt(sentenceText: string, position: number, options: ParseOptions): ExpectedAtResult;
    expectedTerminalsAt(sentenceText: string, position: number, options: ParseOptions): KtSet<Rule>;
    readonly __doNotUseOrImplementIt: Parser["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LeftCornerParser.$metadata$ {
    const constructor: abstract new () => LeftCornerParser;
}
export declare class RuntimeParserExternal implements RuntimeParser {
    constructor();
    readonly __doNotUseOrImplementIt: RuntimeParser["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeParserExternal.$metadata$ {
    const constructor: abstract new () => RuntimeParserExternal;
}
export declare interface RuleSet {
    readonly rule: KtList<Rule>;
    readonly nonSkipTerminals: KtList<Rule>;
    readonly terminals: KtList<Rule>;
    readonly embeddedTerminals: KtList<Rule>;
    readonly goalRuleFor: MapNotNull<Rule, Rule>;
    automatonFor(goalRuleName: string, automatonKind: AutomatonKind): Automaton;
    usedAutomatonFor(goalRuleName: string): Automaton;
    addPreBuiltFor(userGoalRuleName: string, automaton: Automaton): void;
    clone(): RuleSet;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.RuleSet": unique symbol;
    };
}
export declare interface Rule {
    readonly ruleSetNumber: number;
    readonly number: number;
    readonly tag: string;
    readonly isSkip: boolean;
    readonly isGoal: boolean;
    readonly isPseudo: boolean;
    readonly isTerminal: boolean;
    readonly isEndOfText: boolean;
    readonly isEmptyTerminal: boolean;
    readonly isEmptyListTerminal: boolean;
    readonly isLiteral: boolean;
    readonly isPattern: boolean;
    readonly isEmbedded: boolean;
    readonly isChoice: boolean;
    readonly isChoiceAmbiguous: boolean;
    readonly isList: boolean;
    readonly isListSimple: boolean;
    readonly isListSeparated: boolean;
    readonly isOptional: boolean;
    readonly isListOptional: boolean;
    readonly rhsItems: KtList<KtList<Rule>>;
    readonly unescapedTerminalValue: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.Rule": unique symbol;
    };
}
export declare interface PrefRule {
    readonly contextRule: Rule;
    readonly options: KtList<PrefOption>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.PrefRule": unique symbol;
    };
}
export declare abstract class Assoc {
    private constructor();
    static get NONE(): Assoc & {
        get name(): "NONE";
        get ordinal(): 0;
    };
    static get LEFT(): Assoc & {
        get name(): "LEFT";
        get ordinal(): 1;
    };
    static get RIGHT(): Assoc & {
        get name(): "RIGHT";
        get ordinal(): 2;
    };
    get name(): "NONE" | "LEFT" | "RIGHT";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<Assoc>;
    static valueOf(value: string): Assoc;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Assoc.$metadata$ {
    const constructor: abstract new () => Assoc;
}
export declare interface PrefOption {
    readonly precedence: number;
    readonly spine: KtList<Rule>;
    readonly option: OptionNum;
    readonly operators: KtSet<Rule>;
    readonly associativity: Assoc;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.PrefOption": unique symbol;
    };
}
export declare class OptionNum /* implements Comparable<OptionNum> */ {
    constructor(value: number);
    get value(): number;
    get asIndex(): number;
    get isEmpty(): boolean;
    get isChoiceOption(): boolean;
    get isNoneOption(): boolean;
    get isOptionalOption(): boolean;
    get isListSimpleOption(): boolean;
    get isListSeparatedOption(): boolean;
    toString(): string;
    copy(value?: number): OptionNum;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OptionNum.$metadata$ {
    const constructor: abstract new () => OptionNum;
}
export declare interface RulePosition {
    readonly rule: Rule;
    readonly option: OptionNum;
    readonly position: number;
    readonly asString: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.RulePosition": unique symbol;
    };
}
export declare abstract class RulePosition {
    static readonly getInstance: () => typeof RulePosition.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RulePosition.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get START_OF_RULE(): number;
        get END_OF_RULE(): number;
        get OPTION_NONE(): OptionNum;
        get OPTION_OPTIONAL_ITEM(): OptionNum;
        get OPTION_OPTIONAL_EMPTY(): OptionNum;
        get OPTION_MULTI_ITEM(): OptionNum;
        get OPTION_MULTI_EMPTY(): OptionNum;
        get OPTION_SLIST_ITEM_OR_SEPERATOR(): OptionNum;
        get OPTION_SLIST_EMPTY(): OptionNum;
        get POSITION_MULIT_ITEM(): number;
        get POSITION_SLIST_SEPARATOR(): number;
        get POSITION_SLIST_ITEM(): number;
        private constructor();
    }
}
export declare interface RuntimeSpine {
    readonly expectedNextTerminals: KtSet<Rule>;
    readonly elements: KtList<RulePosition>;
    readonly nextChildNumber: number;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.RuntimeSpine": unique symbol;
    };
}
export declare interface ExpectedAtResult {
    readonly usedPosition: number;
    readonly spines: KtSet<RuntimeSpine>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.ExpectedAtResult": unique symbol;
    };
}
export declare interface SentenceIdentityFunction {
    invoke(): Nullable<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.SentenceIdentityFunction": unique symbol;
    };
}
export declare interface ParseOptions {
    enabled: boolean;
    goalRuleName: Nullable<string>;
    sentenceIdentity: SentenceIdentityFunction;
    reportErrors: boolean;
    reportGrammarAmbiguities: boolean;
    cacheSkip: boolean;
    reverseFindWordStartRegex: Nullable<string>;
    reverseFindWordStartBySkipRules: boolean;
    clone(): ParseOptions;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.ParseOptions": unique symbol;
    };
}
export declare interface ParseResult {
    readonly sppt: Nullable<SharedPackedParseTree>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.ParseResult": unique symbol;
    };
}
export declare class ParserTerminatedException extends /* RuntimeException */ Error {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParserTerminatedException.$metadata$ {
    const constructor: abstract new () => ParserTerminatedException;
}
export declare interface Parser {
    readonly ruleSet: RuleSet;
    reset(): void;
    interrupt(message: string): void;
    buildFor(goalRuleName: string): void;
    parseForGoal(goalRuleName: string, sentenceText: string): ParseResult;
    parse(sentenceText: string, options: ParseOptions): ParseResult;
    expectedAt(sentenceText: string, position: number, options: ParseOptions): ExpectedAtResult;
    expectedTerminalsAt(sentenceText: string, position: number, options: ParseOptions): KtSet<Rule>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.Parser": unique symbol;
    };
}
export declare interface ParseFailure {
    readonly failedSpines: KtList<RuntimeSpine>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.ParseFailure": unique symbol;
    };
}
export declare interface RuntimeParser {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.RuntimeParser": unique symbol;
    };
}
export declare interface ConcatenationBuilder {
    empty(): void;
    emptyList(): void;
    literal(value: string): void;
    pattern(pattern: string): void;
    ref(name: string): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.ConcatenationBuilder": unique symbol;
    };
}
export declare interface ChoiceBuilder {
    concatenation(init: (p0: ConcatenationBuilder) => void): void;
    ref(ruleName: string): void;
    literal(value: string): void;
    pattern(pattern: string): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.ChoiceBuilder": unique symbol;
    };
}
export declare interface PrecedenceBuilder {
    left(spine: KtList<string>, operatorRuleNames: KtSet<string>): void;
    leftOption(spine: KtList<string>, option: OptionNum, operatorRuleNames: KtSet<string>): void;
    right(spine: KtList<string>, operatorRuleNames: KtSet<string>): void;
    rightOption(spine: KtList<string>, option: OptionNum, operatorRuleNames: KtSet<string>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.parser.api.PrecedenceBuilder": unique symbol;
    };
}
export declare abstract class IssueMessage {
    static readonly getInstance: () => typeof IssueMessage.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IssueMessage.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get PARSER_WONT_STOP(): string;
        private constructor();
    }
}
export declare class GraphStructuredStack<E> {
    constructor(_growingHeadHeap: any/* BinaryHeap<E, E> */, previous: KtMutableMap<E, KtMutableSet<E>>, count: KtMutableMap<E, number>);
    get _growingHeadHeap(): any/* BinaryHeap<E, E> */;
    static new_net_akehurst_language_agl_runtime_graph_GraphStructuredStack<E>(headHeap: any/* BinaryHeap<E, E> */): GraphStructuredStack<E>;
    get roots(): KtList<E>;
    get isEmpty(): boolean;
    get numberOfHeads(): number;
    get hasNextHead(): boolean;
    get peekFirstHead(): Nullable<E>;
    get heads(): KtList<E>;
    extractRoot(): E;
    clear(): void;
    root(head: E): boolean;
    pushTriple(cur: E, prev: Nullable<E>, rhd: Nullable<E>): void;
    push(currentHead: E, nextHead: E): void;
    contains(head: E): boolean;
    peekPrevious(head: E): KtSet<E>;
    pop(head: E): KtSet<E>;
    snapshotFor(head: E): Nullable<KtMap<E, KtSet<E>>>;
    dropStack(head: E, ifDropped: (p0: E) => void): boolean;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GraphStructuredStack.$metadata$ {
    const constructor: abstract new <E>() => GraphStructuredStack<E>;
}
export declare class RuleOption {
    constructor(runtimeRule: RuntimeRule, option: OptionNum);
    get runtimeRule(): RuntimeRule;
    get option(): OptionNum;
    get isGoal(): boolean;
    toString(): string;
    copy(runtimeRule?: RuntimeRule, option?: OptionNum): RuleOption;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleOption.$metadata$ {
    const constructor: abstract new () => RuleOption;
}
export declare class RulePositionRuntime implements RulePosition {
    constructor(rule: RuntimeRule, option: OptionNum, position: number);
    get rule(): RuntimeRule;
    get option(): OptionNum;
    get position(): number;
    get identity(): RuleOption;
    get isAtStart(): boolean;
    get isAtEnd(): boolean;
    get isGoal(): boolean;
    get isTerminal(): boolean;
    get isEmbedded(): boolean;
    get items(): KtSet<RuntimeRule>;
    get asString(): string;
    atEnd(): RulePositionRuntime;
    next(): KtSet<RulePositionRuntime>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: RulePosition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RulePositionRuntime.$metadata$ {
    const constructor: abstract new () => RulePositionRuntime;
}
export declare class RuntimePreferenceRule implements PrefRule {
    constructor(contextRule: RuntimeRule, options: KtList<RuntimePreferenceRule.RuntimePreferenceOption>);
    get contextRule(): RuntimeRule;
    get options(): KtList<RuntimePreferenceRule.RuntimePreferenceOption>;
    readonly __doNotUseOrImplementIt: PrefRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimePreferenceRule.$metadata$ {
    const constructor: abstract new () => RuntimePreferenceRule;
}
export declare namespace RuntimePreferenceRule {
    class RuntimePreferenceOption implements PrefOption {
        constructor(precedence: number, spine: KtList<RuntimeRule>, option: OptionNum, operators: KtSet<RuntimeRule>, associativity: Assoc);
        get precedence(): number;
        get spine(): KtList<RuntimeRule>;
        get option(): OptionNum;
        get operators(): KtSet<RuntimeRule>;
        get associativity(): Assoc;
        copy(precedence?: number, spine?: KtList<RuntimeRule>, option?: OptionNum, operators?: KtSet<RuntimeRule>, associativity?: Assoc): RuntimePreferenceRule.RuntimePreferenceOption;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
        readonly __doNotUseOrImplementIt: PrefOption["__doNotUseOrImplementIt"];
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace RuntimePreferenceOption.$metadata$ {
        const constructor: abstract new () => RuntimePreferenceOption;
    }
}
export declare class RuntimeRule implements Rule {
    constructor(ruleSetNumber: number, number: number, name: Nullable<string>, isSkip: boolean, isPseudo: boolean);
    get ruleSetNumber(): number;
    get number(): number;
    get name(): Nullable<string>;
    get isSkip(): boolean;
    get isPseudo(): boolean;
    setRhs(value: RuntimeRuleRhs): void;
    get rhs(): RuntimeRuleRhs;
    get isExplicitlyNamed(): boolean;
    get tag(): string;
    get isGoal(): boolean;
    get isEndOfText(): boolean;
    get isEmptyTerminal(): boolean;
    get isEmptyListTerminal(): boolean;
    get isEmbedded(): boolean;
    get isPattern(): boolean;
    get isLiteral(): boolean;
    get isTerminal(): boolean;
    get isNonTerminal(): boolean;
    get isChoice(): boolean;
    get isChoiceAmbiguous(): boolean;
    get isOptional(): boolean;
    get isListOptional(): boolean;
    get isList(): boolean;
    get isListSimple(): boolean;
    get isListSeparated(): boolean;
    get rhsItems(): KtList<KtList<Rule>>;
    get unescapedTerminalValue(): string;
    get asString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: Rule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRule.$metadata$ {
    const constructor: abstract new () => RuntimeRule;
}
export declare abstract class RuntimeRuleKind {
    private constructor();
    static get GOAL(): RuntimeRuleKind & {
        get name(): "GOAL";
        get ordinal(): 0;
    };
    static get NON_TERMINAL(): RuntimeRuleKind & {
        get name(): "NON_TERMINAL";
        get ordinal(): 1;
    };
    static get TERMINAL(): RuntimeRuleKind & {
        get name(): "TERMINAL";
        get ordinal(): 2;
    };
    static get EMBEDDED(): RuntimeRuleKind & {
        get name(): "EMBEDDED";
        get ordinal(): 3;
    };
    get name(): "GOAL" | "NON_TERMINAL" | "TERMINAL" | "EMBEDDED";
    get ordinal(): 0 | 1 | 2 | 3;
    static values(): Array<RuntimeRuleKind>;
    static valueOf(value: string): RuntimeRuleKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleKind.$metadata$ {
    const constructor: abstract new () => RuntimeRuleKind;
}
export declare abstract class RuntimeRuleRhsItemsKind {
    private constructor();
    static get EMPTY(): RuntimeRuleRhsItemsKind & {
        get name(): "EMPTY";
        get ordinal(): 0;
    };
    static get CONCATENATION(): RuntimeRuleRhsItemsKind & {
        get name(): "CONCATENATION";
        get ordinal(): 1;
    };
    static get CHOICE(): RuntimeRuleRhsItemsKind & {
        get name(): "CHOICE";
        get ordinal(): 2;
    };
    static get LIST(): RuntimeRuleRhsItemsKind & {
        get name(): "LIST";
        get ordinal(): 3;
    };
    get name(): "EMPTY" | "CONCATENATION" | "CHOICE" | "LIST";
    get ordinal(): 0 | 1 | 2 | 3;
    static values(): Array<RuntimeRuleRhsItemsKind>;
    static valueOf(value: string): RuntimeRuleRhsItemsKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsItemsKind.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsItemsKind;
}
export declare abstract class RuntimeRuleListKind {
    private constructor();
    static get MULTI(): RuntimeRuleListKind & {
        get name(): "MULTI";
        get ordinal(): 0;
    };
    static get SEPARATED_LIST(): RuntimeRuleListKind & {
        get name(): "SEPARATED_LIST";
        get ordinal(): 1;
    };
    static get LEFT_ASSOCIATIVE_LIST(): RuntimeRuleListKind & {
        get name(): "LEFT_ASSOCIATIVE_LIST";
        get ordinal(): 2;
    };
    static get RIGHT_ASSOCIATIVE_LIST(): RuntimeRuleListKind & {
        get name(): "RIGHT_ASSOCIATIVE_LIST";
        get ordinal(): 3;
    };
    static get UNORDERED(): RuntimeRuleListKind & {
        get name(): "UNORDERED";
        get ordinal(): 4;
    };
    get name(): "MULTI" | "SEPARATED_LIST" | "LEFT_ASSOCIATIVE_LIST" | "RIGHT_ASSOCIATIVE_LIST" | "UNORDERED";
    get ordinal(): 0 | 1 | 2 | 3 | 4;
    static values(): Array<RuntimeRuleListKind>;
    static valueOf(value: string): RuntimeRuleListKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleListKind.$metadata$ {
    const constructor: abstract new () => RuntimeRuleListKind;
}
export declare abstract class RuntimeRuleChoiceKind {
    private constructor();
    static get NONE(): RuntimeRuleChoiceKind & {
        get name(): "NONE";
        get ordinal(): 0;
    };
    static get AMBIGUOUS(): RuntimeRuleChoiceKind & {
        get name(): "AMBIGUOUS";
        get ordinal(): 1;
    };
    static get LONGEST_PRIORITY(): RuntimeRuleChoiceKind & {
        get name(): "LONGEST_PRIORITY";
        get ordinal(): 2;
    };
    static get PRIORITY_LONGEST(): RuntimeRuleChoiceKind & {
        get name(): "PRIORITY_LONGEST";
        get ordinal(): 3;
    };
    get name(): "NONE" | "AMBIGUOUS" | "LONGEST_PRIORITY" | "PRIORITY_LONGEST";
    get ordinal(): 0 | 1 | 2 | 3;
    static values(): Array<RuntimeRuleChoiceKind>;
    static valueOf(value: string): RuntimeRuleChoiceKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleChoiceKind.$metadata$ {
    const constructor: abstract new () => RuntimeRuleChoiceKind;
}
export declare abstract class RuntimeRuleRhs {
    protected constructor(rule: RuntimeRule);
    get rule(): RuntimeRule;
    abstract get rhsItems(): KtList<KtList<Rule>>;
    abstract get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    abstract get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    get asString(): string;
    abstract rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    abstract nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    abstract clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhs.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhs;
}
export declare abstract class RuntimeRuleRhsTerminal extends RuntimeRuleRhs.$metadata$.constructor {
    protected constructor(rule: RuntimeRule);
    abstract get matchable(): Nullable<Matchable>;
    get rhsItems(): KtList<KtList<Rule>>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsTerminal.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsTerminal;
}
export declare class RuntimeRuleRhsEmpty extends RuntimeRuleRhsTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule);
    get matchable(): Nullable<never>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsEmpty.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsEmpty;
}
export declare class RuntimeRuleRhsEmptyList extends RuntimeRuleRhsTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule);
    get matchable(): Nullable<never>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsEmptyList.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsEmptyList;
}
export declare class RuntimeRuleRhsCommonTerminal extends RuntimeRuleRhsTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule);
    get matchable(): Matchable;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsCommonTerminal.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsCommonTerminal;
}
export declare class RuntimeRuleRhsPattern extends RuntimeRuleRhsTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, patternUnescaped: UnescapedPattern);
    get patternUnescaped(): UnescapedPattern;
    get matchable(): Matchable;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsPattern.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsPattern;
}
export declare class RuntimeRuleRhsLiteral extends RuntimeRuleRhsTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, literalUnescaped: UnescapedLiteral);
    get literalUnescaped(): UnescapedLiteral;
    get matchable(): Matchable;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsLiteral.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsLiteral;
}
export declare class RuntimeRuleRhsEmbedded extends RuntimeRuleRhsTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, embeddedRuntimeRuleSet: RuntimeRuleSet, embeddedStartRule: RuntimeRule);
    get embeddedRuntimeRuleSet(): RuntimeRuleSet;
    get embeddedStartRule(): RuntimeRule;
    get matchable(): Nullable<never>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    get asString(): string;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsEmbedded.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsEmbedded;
}
export declare abstract class RuntimeRuleRhsNonTerminal extends RuntimeRuleRhs.$metadata$.constructor {
    protected constructor(rule: RuntimeRule);
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsNonTerminal.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsNonTerminal;
}
export declare class RuntimeRuleRhsGoal extends RuntimeRuleRhsNonTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, userGoalRuleItem: RuntimeRule);
    get userGoalRuleItem(): RuntimeRule;
    get rhsItems(): KtList<KtList<RuntimeRule>>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsGoal.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsGoal;
}
export declare class RuntimeRuleRhsConcatenation extends RuntimeRuleRhsNonTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, concatItems: KtList<RuntimeRule>);
    get concatItems(): KtList<RuntimeRule>;
    get rhsItems(): KtList<KtList<RuntimeRule>>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    get asString(): string;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsConcatenation.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsConcatenation;
}
export declare class RuntimeRuleRhsChoice extends RuntimeRuleRhsNonTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, choiceKind: RuntimeRuleChoiceKind, options: KtList<RuntimeRuleRhs>);
    get choiceKind(): RuntimeRuleChoiceKind;
    get options(): KtList<RuntimeRuleRhs>;
    get rhsItems(): KtList<KtList<Rule>>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    get asString(): string;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsChoice.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsChoice;
}
export declare class RuntimeRuleRhsOptional extends RuntimeRuleRhsNonTerminal.$metadata$.constructor {
    constructor(rule: RuntimeRule, optionalItem: RuntimeRule);
    get optionalItem(): RuntimeRule;
    get rhsItems(): KtList<KtList<Rule>>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsOptional.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsOptional;
}
export declare abstract class RuntimeRuleRhsList extends RuntimeRuleRhsNonTerminal.$metadata$.constructor {
    protected constructor(rule: RuntimeRule);
    abstract get min(): number;
    abstract get max(): number;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsList.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsList;
}
export declare namespace RuntimeRuleRhsList {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get MULTIPLICITY_N(): number;
            private constructor();
        }
    }
}
export declare class RuntimeRuleRhsListSimple extends RuntimeRuleRhsList.$metadata$.constructor {
    constructor(rule: RuntimeRule, min: number, max: number, repeatedRhsItem: RuntimeRule);
    get min(): number;
    get max(): number;
    get repeatedRhsItem(): RuntimeRule;
    get rhsItems(): KtList<KtList<Rule>>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsListSimple.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsListSimple;
}
export declare class RuntimeRuleRhsListSeparated extends RuntimeRuleRhsList.$metadata$.constructor {
    constructor(rule: RuntimeRule, min: number, max: number, repeatedRhsItem: RuntimeRule, separatorRhsItem: RuntimeRule);
    get min(): number;
    get max(): number;
    get repeatedRhsItem(): RuntimeRule;
    get separatorRhsItem(): RuntimeRule;
    get rhsItems(): KtList<KtList<Rule>>;
    get rulePositionsAtStart(): KtSet<RulePositionRuntime>;
    get rulePositionsNotAtStart(): KtSet<RulePositionRuntime>;
    rhsItemsAt(option: OptionNum, position: number): KtSet<RuntimeRule>;
    nextRulePositions(current: RulePositionRuntime): KtSet<RulePositionRuntime>;
    clone(clonedRules: KtMap<string, RuntimeRule>): RuntimeRuleRhs;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleRhsListSeparated.$metadata$ {
    const constructor: abstract new () => RuntimeRuleRhsListSeparated;
}
export declare class RuntimeRuleSet implements RuleSet {
    constructor(number: number, qualifiedName: string, runtimeRules: KtList<RuntimeRule>, precedenceRules: KtList<PrefRule>);
    get number(): number;
    get qualifiedName(): string;
    get runtimeRules(): KtList<RuntimeRule>;
    get precedenceRules(): KtList<PrefRule>;
    get goalRuleFor(): MapNotNull<Rule, Rule>;
    get skipRules(): KtList<RuntimeRule>;
    get skipTerminals(): KtSet<RuntimeRule>;
    get nonSkipRules(): Array<RuntimeRule>;
    get nonSkipTerminals(): KtList<RuntimeRule>;
    get terminals(): KtList<RuntimeRule>;
    get embeddedTerminals(): KtList<RuntimeRule>;
    get skipParserStateSet(): Nullable<ParserStateSet>;
    automatonFor(goalRuleName: string, automatonKind: AutomatonKind): Automaton;
    usedAutomatonFor(goalRuleName: string): Automaton;
    buildFor(userGoalRuleName: string, automatonKind: AutomatonKind): ParserStateSet;
    addPreBuiltFor(userGoalRuleName: string, automaton: Automaton): void;
    fetchStateSetFor(userGoalRule: Rule, automatonKind: AutomatonKind): ParserStateSet;
    findEmbeddedRuleSets(found?: KtSet<RuntimeRuleSet>): KtSet<RuntimeRuleSet>;
    findRuntimeRule(tag: string): RuntimeRule;
    findTerminalRule(tag: string): RuntimeRule;
    usedAutomatonToString(userGoalRuleName: string, withStates?: boolean): string;
    calcUsedRules(rule: RuntimeRule, used?: KtMutableSet<RuntimeRule>, done?: any /*BooleanArray*/): KtSet<RuntimeRule>;
    clone(): RuntimeRuleSet;
    get rule(): KtList<Rule>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: RuleSet["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuntimeRuleSet.$metadata$ {
    const constructor: abstract new () => RuntimeRuleSet;
}
export declare namespace RuntimeRuleSet {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get nextRuntimeRuleSetNumber(): number;
            set nextRuntimeRuleSetNumber(value: number);
            get numberForGrammar(): MapNotNull<string, number>/* LazyMapNotNull<string, number> */;
            get NO_RRS(): number;
            get GOAL_RULE_NUMBER(): number;
            get EOT_RULE_NUMBER(): number;
            get SKIP_RULE_NUMBER(): number;
            get SKIP_CHOICE_RULE_NUMBER(): number;
            get RUNTIME_LOOKAHEAD_RULE_NUMBER(): number;
            get ANY_LOOKAHEAD_RULE_NUMBER(): number;
            get UNDEFINED_LOOKAHEAD_RULE_NUMBER(): number;
            get EMPTY_RULE_NUMBER(): number;
            get EMPTY_LIST_RULE_NUMBER(): number;
            get END_OF_TEXT_TAG(): string;
            get GOAL_TAG(): string;
            get SKIP_MULTI_TAG(): string;
            get SKIP_CHOICE_RULE_TAG(): string;
            get RUNTIME_LOOKAHEAD_RULE_TAG(): string;
            get ANY_LOOKAHEAD_RULE_TAG(): string;
            get UNDEFINED_LOOKAHEAD_RULE_TAG(): string;
            get EMPTY_RULE_TAG(): string;
            get EMPTY_LIST_RULE_TAG(): string;
            get END_OF_TEXT(): RuntimeRule;
            get USE_RUNTIME_LOOKAHEAD(): RuntimeRule;
            get ANY_LOOKAHEAD(): RuntimeRule;
            get UNDEFINED_RULE(): RuntimeRule;
            get EMPTY(): RuntimeRule;
            get EMPTY_LIST(): RuntimeRule;
            private constructor();
        }
    }
}
export declare function ruleSet(name: string, init: (p0: any/* RuleSetBuilder */) => void): RuleSet;
export declare interface ScanResult {
    readonly tokensByLine: KtList<KtList<LeafData>>;
    readonly allTokens: KtList<LeafData>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.scanner.api.ScanResult": unique symbol;
    };
}
export declare abstract class ScannerKind {
    private constructor();
    static get OnDemand(): ScannerKind & {
        get name(): "OnDemand";
        get ordinal(): 0;
    };
    static get Classic(): ScannerKind & {
        get name(): "Classic";
        get ordinal(): 1;
    };
    get name(): "OnDemand" | "Classic";
    get ordinal(): 0 | 1;
    static values(): Array<ScannerKind>;
    static valueOf(value: string): ScannerKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScannerKind.$metadata$ {
    const constructor: abstract new () => ScannerKind;
}
export declare interface Scanner {
    readonly kind: ScannerKind;
    readonly regexEngine: RegexEngine;
    readonly matchables: KtList<Matchable>;
    reset(): void;
    isEnd(sentence: Sentence, position: number): boolean;
    isLookingAt(sentence: Sentence, position: number, terminalRule: Rule): boolean;
    matchedLength(sentence: Sentence, position: number, terminalRule: Rule): number;
    findOrTryCreateLeaf(sentence: Sentence, position: number, terminalRule: Rule): Nullable<SpptDataNode>;
    scan(sentence: Sentence, options?: Nullable<ScanOptions>): ScanResult;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.scanner.api.Scanner": unique symbol;
    };
}
export declare interface ScanOptions {
    enabled: boolean;
    resultsByLine: boolean;
    startAtPosition: number;
    offsetPosition: number;
    clone(): ScanOptions;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.scanner.api.ScanOptions": unique symbol;
    };
}
export declare abstract class MatchableKind {
    private constructor();
    static get EOT(): MatchableKind & {
        get name(): "EOT";
        get ordinal(): 0;
    };
    static get LITERAL(): MatchableKind & {
        get name(): "LITERAL";
        get ordinal(): 1;
    };
    static get REGEX(): MatchableKind & {
        get name(): "REGEX";
        get ordinal(): 2;
    };
    get name(): "EOT" | "LITERAL" | "REGEX";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<MatchableKind>;
    static valueOf(value: string): MatchableKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MatchableKind.$metadata$ {
    const constructor: abstract new () => MatchableKind;
}
export declare class Matchable {
    constructor(ruleSetNumber: number, ruleNumber: number, tag: string, expression: UnescapedValue, kind: MatchableKind);
    get ruleSetNumber(): number;
    get ruleNumber(): number;
    get tag(): string;
    get expression(): UnescapedValue;
    get kind(): MatchableKind;
    using(regexEngine: RegexEngine): Matchable;
    isLookingAt(sentence: Sentence, atPosition: number): boolean;
    matchedLength(sentence: Sentence, atPosition: number): number;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Matchable.$metadata$ {
    const constructor: abstract new () => Matchable;
}
export declare class ScanOptionsDefault implements ScanOptions {
    constructor(enabled?: boolean, resultsByLine?: boolean, startAtPosition?: number, offsetPosition?: number);
    get enabled(): boolean;
    set enabled(value: boolean);
    get resultsByLine(): boolean;
    set resultsByLine(value: boolean);
    get startAtPosition(): number;
    set startAtPosition(value: number);
    get offsetPosition(): number;
    set offsetPosition(value: number);
    clone(): ScanOptionsDefault;
    readonly __doNotUseOrImplementIt: ScanOptions["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScanOptionsDefault.$metadata$ {
    const constructor: abstract new () => ScanOptionsDefault;
}
export declare class ScanResultDefault implements ScanResult {
    constructor(tokensByLine: KtList<KtList<LeafData>>, issues: IssueCollection<LanguageIssue>);
    get tokensByLine(): KtList<KtList<LeafData>>;
    get issues(): IssueCollection<LanguageIssue>;
    get allTokens(): KtList<LeafData>;
    copy(tokensByLine?: KtList<KtList<LeafData>>, issues?: IssueCollection<LanguageIssue>): ScanResultDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ScanResult["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScanResultDefault.$metadata$ {
    const constructor: abstract new () => ScanResultDefault;
}
export declare class ScanByLineEndState {
    constructor(tokens: KtList<LeafData>, eolPosition: number, leftOverText: string);
    get tokens(): KtList<LeafData>;
    get eolPosition(): number;
    get leftOverText(): string;
    copy(tokens?: KtList<LeafData>, eolPosition?: number, leftOverText?: string): ScanByLineEndState;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScanByLineEndState.$metadata$ {
    const constructor: abstract new () => ScanByLineEndState;
}
export declare abstract class ScannerAbstract implements Scanner {
    constructor(regexEngine: RegexEngine);
    get regexEngine(): RegexEngine;
    abstract get validTerminals(): KtList<Rule>;
    get matchables(): KtList<Matchable>;
    isEnd(sentence: Sentence, position: number): boolean;
    matchedLength(sentence: Sentence, position: number, terminalRule: Rule): number;
    scan(sentence: Sentence, options?: Nullable<ScanOptions>): ScanResult;
    scanByLine(previousState: ScanByLineEndState, sentence: Sentence, offsetPosition: number): ScanByLineEndState;
    abstract get kind(): ScannerKind;
    abstract reset(): void;
    abstract isLookingAt(sentence: Sentence, position: number, terminalRule: Rule): boolean;
    abstract findOrTryCreateLeaf(sentence: Sentence, position: number, terminalRule: Rule): Nullable<SpptDataNode>;
    readonly __doNotUseOrImplementIt: Scanner["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScannerAbstract.$metadata$ {
    const constructor: abstract new () => ScannerAbstract;
}
export declare class ScannerClassic extends ScannerAbstract.$metadata$.constructor {
    constructor(regexEngine: RegexEngine, terminals: KtList<Rule>);
    get validTerminals(): KtList<Rule>;
    get kind(): ScannerKind;
    reset(): void;
    isEnd(sentence: Sentence, position: number): boolean;
    isLookingAt(sentence: Sentence, position: number, terminalRule: Rule): boolean;
    findOrTryCreateLeaf(sentence: Sentence, position: number, terminalRule: Rule): Nullable<CompleteTreeDataNode>;
    scan(sentence: Sentence, options?: Nullable<ScanOptions>): ScanResult;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScannerClassic.$metadata$ {
    const constructor: abstract new () => ScannerClassic;
}
export declare namespace ScannerClassic {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get LEAF_NONE(): CompleteTreeDataNode;
            private constructor();
        }
    }
}
export declare class ScannerFromMatchables extends ScannerAbstract.$metadata$.constructor {
    constructor(regexEngine: RegexEngine | undefined, _matchables: () => KtList<Matchable>);
    get matchables(): KtList<Matchable>;
    get kind(): ScannerKind;
    get validTerminals(): KtList<Rule>;
    reset(): void;
    isLookingAt(sentence: Sentence, position: number, terminalRule: Rule): boolean;
    findOrTryCreateLeaf(sentence: Sentence, position: number, terminalRule: Rule): CompleteTreeDataNode;
    scan(sentence: Sentence, options?: Nullable<ScanOptions>): ScanResult;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScannerFromMatchables.$metadata$ {
    const constructor: abstract new () => ScannerFromMatchables;
}
export declare class ScannerOnDemand extends ScannerAbstract.$metadata$.constructor {
    constructor(regexEngine: RegexEngine, terminals: KtList<Rule>);
    get validTerminals(): KtList<Rule>;
    get kind(): ScannerKind;
    reset(): void;
    isLookingAt(sentence: Sentence, position: number, terminalRule: Rule): boolean;
    findOrTryCreateLeaf(sentence: Sentence, position: number, terminalRule: Rule): Nullable<CompleteTreeDataNode>;
    scan(sentence: Sentence, options?: Nullable<ScanOptions>): ScanResult;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScannerOnDemand.$metadata$ {
    const constructor: abstract new () => ScannerOnDemand;
}
export declare namespace ScannerOnDemand {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get END_OF_TEXT(): string;
            get LEAF_NONE(): CompleteTreeDataNode;
            private constructor();
        }
    }
}
export declare class SentenceDefault extends SentenceAbstract.$metadata$.constructor {
    constructor(text: string, identity: Nullable<any>);
    get text(): string;
    get eolPositions(): KtList<number>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SentenceDefault.$metadata$ {
    const constructor: abstract new () => SentenceDefault;
}
export declare namespace SentenceDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get EOL_PATTERN(): any/* Regex */;
            eolPositions(text: string): KtList<number>;
            private constructor();
        }
    }
}
export declare abstract class SentenceAbstract implements Sentence {
    constructor(identity: Nullable<any>);
    get identity(): Nullable<any>;
    abstract get text(): string;
    abstract get eolPositions(): KtList<number>;
    textAt(position: number, length: number): string;
    positionOfLine(line: number): number;
    locationInLine(line: number, position: number, length: number): InputLocation;
    locationFor(position: number, length: number): InputLocation;
    contextInText(position: number): string;
    readonly __doNotUseOrImplementIt: Sentence["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SentenceAbstract.$metadata$ {
    const constructor: abstract new () => SentenceAbstract;
}
export declare namespace SentenceAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get contextSize(): number;
            private constructor();
        }
    }
}
export declare interface Sentence {
    readonly text: string;
    textAt(position: number, length: number): string;
    positionOfLine(line: number): number;
    locationInLine(line: number, position: number, length: number): InputLocation;
    locationFor(position: number, length: number): InputLocation;
    contextInText(position: number): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sentence.api.Sentence": unique symbol;
    };
}
export declare class InputLocation {
    constructor(position: number, column: number, line: number, length: number, sentenceIdentity: Nullable<any>);
    get position(): number;
    get column(): number;
    get line(): number;
    get length(): number;
    set length(value: number);
    get sentenceIdentity(): Nullable<any>;
    get endPosition(): number;
    copy(position?: number, column?: number, line?: number, length?: number, sentenceIdentity?: Nullable<any>): InputLocation;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace InputLocation.$metadata$ {
    const constructor: abstract new () => InputLocation;
}
export declare interface SPPTBranch extends SPPTNode {
    readonly childrenAlternatives: KtMap<number, KtList<SPPTNode>>;
    readonly children: KtList<SPPTNode>;
    readonly nonSkipChildren: KtList<SPPTNode>;
    nonSkipChild(index: number): SPPTNode;
    branchChild(index: number): SPPTBranch;
    readonly branchNonSkipChildren: KtList<SPPTBranch>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SPPTBranch": unique symbol;
    } & SPPTNode["__doNotUseOrImplementIt"];
}
export declare interface SPPTLeaf extends SPPTNode {
    readonly isPattern: boolean;
    readonly isLiteral: boolean;
    readonly isExplicitlyNamed: boolean;
    readonly tagList: KtList<string>;
    readonly eolPositions: KtList<number>;
    readonly metaTags: KtList<string>;
    setTags(arg: KtList<string>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SPPTLeaf": unique symbol;
    } & SPPTNode["__doNotUseOrImplementIt"];
}
export declare interface SPPTNode {
    readonly name: string;
    readonly runtimeRuleSetNumber: number;
    readonly runtimeRuleNumber: number;
    readonly option: number;
    readonly location: InputLocation;
    readonly lastLeaf: SPPTLeaf;
    readonly startPosition: number;
    readonly matchedTextLength: number;
    readonly nextInputPosition: number;
    readonly priority: number;
    readonly matchedText: string;
    readonly nonSkipMatchedText: string;
    readonly numberOfLines: number;
    readonly isEmptyLeaf: boolean;
    readonly isEmptyMatch: boolean;
    readonly isLeaf: boolean;
    readonly isOptional: boolean;
    readonly isList: boolean;
    readonly isEmbedded: boolean;
    readonly isBranch: boolean;
    readonly isSkip: boolean;
    readonly asLeaf: SPPTLeaf;
    readonly asBranch: SPPTBranch;
    parent: Nullable<SPPTBranch>;
    tree: Nullable<SharedPackedParseTree>;
    contains(other: SPPTNode): boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SPPTNode": unique symbol;
    };
}
export declare interface SPPTParser {
    readonly tree: SharedPackedParseTree;
    clear(): void;
    parse(treeAsString: string, addTree?: boolean): SharedPackedParseTree;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SPPTParser": unique symbol;
    };
}
export declare interface SpptDataNode {
    readonly rule: Rule;
    readonly startPosition: number;
    readonly nextInputPosition: number;
    readonly nextInputNoSkip: number;
    readonly option: OptionNum;
    readonly dynamicPriority: KtList<number>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SpptDataNode": unique symbol;
    };
}
export declare class ChildInfo {
    constructor(propertyIndex: number, index: number, total: number);
    get propertyIndex(): number;
    get index(): number;
    get total(): number;
    copy(propertyIndex?: number, index?: number, total?: number): ChildInfo;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChildInfo.$metadata$ {
    const constructor: abstract new () => ChildInfo;
}
export declare class AltInfo {
    constructor(option: OptionNum, index: number, totalMatched: number);
    get option(): OptionNum;
    get index(): number;
    get totalMatched(): number;
    copy(option?: OptionNum, index?: number, totalMatched?: number): AltInfo;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AltInfo.$metadata$ {
    const constructor: abstract new () => AltInfo;
}
export declare class ParsePath {
    constructor(segments?: KtList<string>);
    get segments(): KtList<string>;
    plus(segment: string): ParsePath;
    toString(): string;
    copy(segments?: KtList<string>): ParsePath;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParsePath.$metadata$ {
    const constructor: abstract new () => ParsePath;
}
export declare interface SpptDataNodeInfo {
    readonly path: ParsePath;
    readonly node: SpptDataNode;
    readonly parentAlt: AltInfo;
    readonly alt: AltInfo;
    readonly child: ChildInfo;
    readonly numChildrenAlternatives: KtMap<OptionNum, number>;
    readonly totalChildrenFromAllAlternatives: number;
    readonly numSkipChildren: number;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SpptDataNodeInfo": unique symbol;
    };
}
export declare interface PathFunction {
    invoke(): KtList<SpptDataNode>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.PathFunction": unique symbol;
    };
}
export declare interface SpptWalker {
    beginTree(): void;
    endTree(): void;
    skip(skipData: TreeData): void;
    leaf(nodeInfo: SpptDataNodeInfo): void;
    beginBranch(nodeInfo: SpptDataNodeInfo): void;
    endBranch(nodeInfo: SpptDataNodeInfo): void;
    beginEmbedded(nodeInfo: SpptDataNodeInfo): void;
    endEmbedded(nodeInfo: SpptDataNodeInfo): void;
    treeError(msg: string, path: PathFunction): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SpptWalker": unique symbol;
    };
}
export declare class LeafData {
    constructor(name: string, isPattern: boolean, position: number, length: number, tagList: KtList<string>);
    get name(): string;
    get isPattern(): boolean;
    get position(): number;
    get length(): number;
    get tagList(): KtList<string>;
    copy(name?: string, isPattern?: boolean, position?: number, length?: number, tagList?: KtList<string>): LeafData;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LeafData.$metadata$ {
    const constructor: abstract new () => LeafData;
}
export declare interface TreeData {
    readonly root: Nullable<SpptDataNode>;
    readonly userRoot: SpptDataNode;
    readonly initialSkip: Nullable<TreeData>;
    readonly isEmpty: boolean;
    skipDataAfter(node: SpptDataNode): Nullable<TreeData>;
    childrenFor(node: SpptDataNode): KtList<any/* Pair<OptionNum, KtList<SpptDataNode>> */>;
    embeddedFor(node: SpptDataNode): Nullable<TreeData>;
    traverseTreeDepthFirst(callback: SpptWalker, skipDataAsTree: boolean): void;
    preferred(node: SpptDataNode): Nullable<SpptDataNode>;
    skipNodesAfter(node: SpptDataNode): KtList<SpptDataNode>;
    matches(other: TreeData): boolean;
    start(initialSkipData: Nullable<TreeData>): void;
    setRootTo(root: SpptDataNode): void;
    setUserGoalChildrenAfterInitialSkip(nug: SpptDataNode, userGoalChildren: KtList<SpptDataNode>): void;
    setChildren(parent: SpptDataNode, completeChildren: KtList<SpptDataNode>, isAlternative: boolean): void;
    setSkipDataAfter(leafNodeIndex: SpptDataNode, skipData: TreeData): void;
    setEmbeddedTreeFor(n: SpptDataNode, treeData: TreeData): void;
    remove(node: SpptDataNode): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.TreeData": unique symbol;
    };
}
export declare interface SharedPackedParseTree {
    readonly asSentence: string;
    readonly countTrees: number;
    readonly toStringAll: string;
    readonly treeData: TreeData;
    readonly seasons: number;
    readonly maxNumHeads: number;
    traverseTreeDepthFirst(callback: SpptWalker, skipDataAsTree: boolean): void;
    tokensByLineAll(): KtList<KtList<LeafData>>;
    tokensByLine(line: number): KtList<LeafData>;
    toStringAllWithIndent(indentIncrement: string, skipDataAsTree?: boolean): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SharedPackedParseTree": unique symbol;
    };
}
export declare interface SharedPackedParseTreeVisitor<T, A> {
    visitTree(target: SharedPackedParseTree, arg: A): T;
    visitLeaf(target: SPPTLeaf, arg: A): T;
    visitBranch(target: SPPTBranch, arg: A): T;
    visitNode(target: SPPTNode, arg: A): T;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.sppt.api.SharedPackedParseTreeVisitor": unique symbol;
    };
}
export declare class SPPTFromTreeData implements SharedPackedParseTree {
    constructor(treeData: TreeData, sentence: Sentence, seasons: number, maxNumHeads: number);
    get treeData(): TreeData;
    get sentence(): Sentence;
    get seasons(): number;
    get maxNumHeads(): number;
    get asSentence(): string;
    get countTrees(): number;
    get toStringAll(): string;
    traverseTreeDepthFirst(callback: SpptWalker, skipDataAsTree: boolean): void;
    tokensByLineAll(): KtList<KtList<LeafData>>;
    tokensByLine(line: number): KtList<LeafData>;
    toStringAllWithIndent(indentIncrement: string, skipDataAsTree?: boolean): string;
    matches(other: SPPTFromTreeData): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: SharedPackedParseTree["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SPPTFromTreeData.$metadata$ {
    const constructor: abstract new () => SPPTFromTreeData;
}
export declare class SPPTParserDefault implements SPPTParser {
    constructor(rootRuleSet: RuleSet, embeddedRuntimeRuleSets?: KtMap<string, RuntimeRuleSet>);
    get rootRuleSet(): RuleSet;
    get embeddedRuntimeRuleSets(): KtMap<string, RuntimeRuleSet>;
    get tree(): SharedPackedParseTree;
    set tree(value: SharedPackedParseTree);
    clear(): void;
    parse(treeAsString: string, addTree?: boolean): SharedPackedParseTree;
    addTree(treeString: string): SharedPackedParseTree;
    readonly __doNotUseOrImplementIt: SPPTParser["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SPPTParserDefault.$metadata$ {
    const constructor: abstract new () => SPPTParserDefault;
}
export declare function matchedTextNoSkip(_this_: Sentence, node: SpptDataNode): string;
export declare function locationForNode(_this_: Sentence, node: SpptDataNode): InputLocation;
export declare class SpptWalkerToString implements SpptWalker {
    constructor(sentence: Sentence, indentDelta: string);
    get sentence(): Sentence;
    get indentDelta(): string;
    get output(): string;
    beginTree(): void;
    endTree(): void;
    skip(skipData: TreeData): void;
    leaf(nodeInfo: SpptDataNodeInfo): void;
    beginBranch(nodeInfo: SpptDataNodeInfo): void;
    endBranch(nodeInfo: SpptDataNodeInfo): void;
    beginEmbedded(nodeInfo: SpptDataNodeInfo): void;
    endEmbedded(nodeInfo: SpptDataNodeInfo): void;
    treeError(msg: string, path: PathFunction): void;
    readonly __doNotUseOrImplementIt: SpptWalker["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SpptWalkerToString.$metadata$ {
    const constructor: abstract new () => SpptWalkerToString;
}
export declare class PreferredNode {
    constructor(rule: Rule, startPosition: number);
    get rule(): Rule;
    get startPosition(): number;
    toString(): string;
    copy(rule?: Rule, startPosition?: number): PreferredNode;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PreferredNode.$metadata$ {
    const constructor: abstract new () => PreferredNode;
}
export declare class CompleteTreeDataNode implements SpptDataNode {
    constructor(rule: Rule, startPosition: number, nextInputPosition: number, nextInputNoSkip: number, option: OptionNum, dynamicPriority: KtList<number>);
    get rule(): Rule;
    get startPosition(): number;
    get nextInputPosition(): number;
    get nextInputNoSkip(): number;
    get option(): OptionNum;
    get dynamicPriority(): KtList<number>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: SpptDataNode["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompleteTreeDataNode.$metadata$ {
    const constructor: abstract new () => CompleteTreeDataNode;
}
export declare function treeData(forStateSetNumber: number): TreeData;
export declare class TreeDataComplete implements TreeData {
    constructor(forStateSetNumber: number);
    get forStateSetNumber(): number;
    get isEmpty(): boolean;
    get completeChildren(): KtMap<SpptDataNode, KtMap<OptionNum, KtList<SpptDataNode>>>;
    get root(): Nullable<SpptDataNode>;
    set root(value: Nullable<SpptDataNode>);
    get initialSkip(): Nullable<TreeData>;
    set initialSkip(value: Nullable<TreeData>);
    get userRoot(): SpptDataNode;
    setUserGoalChildrenAfterInitialSkip(nug: SpptDataNode, userGoalChildren: KtList<SpptDataNode>): void;
    childrenFor(node: SpptDataNode): KtList<any/* Pair<OptionNum, KtList<SpptDataNode>> */>;
    skipDataAfter(node: SpptDataNode): Nullable<TreeData>;
    embeddedFor(node: SpptDataNode): Nullable<TreeData>;
    skipNodesAfter(node: SpptDataNode): KtList<SpptDataNode>;
    reset(): void;
    preferred(node: SpptDataNode): Nullable<SpptDataNode>;
    setRootTo(root: SpptDataNode): void;
    start(initialSkipData: Nullable<TreeData>): void;
    remove(node: SpptDataNode): void;
    setChildren(parent: SpptDataNode, completeChildren: KtList<SpptDataNode>, isAlternative: boolean): void;
    setSkipDataAfter(leafNodeIndex: SpptDataNode, skipData: TreeData): void;
    setEmbeddedTreeFor(n: SpptDataNode, treeData: TreeData): void;
    traverseTreeDepthFirst(callback: SpptWalker, skipDataAsTree: boolean): void;
    matches(other: TreeData): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: TreeData["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TreeDataComplete.$metadata$ {
    const constructor: abstract new () => TreeDataComplete;
}
export declare namespace TreeDataComplete {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class CompleteKey {
    constructor(rule: Rule, startPosition: number, nextInputPosition: number);
    get rule(): Rule;
    get startPosition(): number;
    get nextInputPosition(): number;
    copy(rule?: Rule, startPosition?: number, nextInputPosition?: number): CompleteKey;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompleteKey.$metadata$ {
    const constructor: abstract new () => CompleteKey;
}
export declare class TreeDataComplete2 implements TreeData {
    constructor(forStateSetNumber: number);
    get forStateSetNumber(): number;
    get isEmpty(): boolean;
    get completeChildren(): KtMap<SpptDataNode, KtMap<OptionNum, KtList<SpptDataNode>>>;
    get root(): Nullable<SpptDataNode>;
    set root(value: Nullable<SpptDataNode>);
    get initialSkip(): Nullable<TreeData>;
    set initialSkip(value: Nullable<TreeData>);
    get userRoot(): SpptDataNode;
    setUserGoalChildrenAfterInitialSkip(nug: SpptDataNode, userGoalChildren: KtList<SpptDataNode>): void;
    childrenFor(node: SpptDataNode): KtList<any/* Pair<OptionNum, KtList<SpptDataNode>> */>;
    skipDataAfter(node: SpptDataNode): Nullable<TreeData>;
    embeddedFor(node: SpptDataNode): Nullable<TreeData>;
    skipNodesAfter(node: SpptDataNode): KtList<SpptDataNode>;
    get _complete(): (KtMap<SpptDataNode, KtMutableMap<OptionNum, KtList<SpptDataNode>>> & KtMutableMap<SpptDataNode, KtMutableMap<OptionNum, KtList<SpptDataNode>>>)/* HashMap<SpptDataNode, KtMutableMap<OptionNum, KtList<SpptDataNode>>> */;
    get _preferred(): (KtMap<PreferredNode, SpptDataNode> & KtMutableMap<PreferredNode, SpptDataNode>)/* HashMap<PreferredNode, SpptDataNode> */;
    get _skipDataAfter(): (KtMap<SpptDataNode, TreeData> & KtMutableMap<SpptDataNode, TreeData>)/* HashMap<SpptDataNode, TreeData> */;
    get _embeddedFor(): (KtMap<SpptDataNode, TreeData> & KtMutableMap<SpptDataNode, TreeData>)/* HashMap<SpptDataNode, TreeData> */;
    reset(): void;
    preferred(node: SpptDataNode): Nullable<SpptDataNode>;
    setRootTo(root: SpptDataNode): void;
    start(initialSkipData: Nullable<TreeData>): void;
    remove(node: SpptDataNode): void;
    setChildren(parent: SpptDataNode, completeChildren: KtList<SpptDataNode>, isAlternative: boolean): void;
    setSkipDataAfter(leafNodeIndex: SpptDataNode, skipData: TreeData): void;
    setEmbeddedTreeFor(n: SpptDataNode, treeData: TreeData): void;
    traverseTreeDepthFirst(callback: SpptWalker, skipDataAsTree: boolean): void;
    matches(other: TreeData): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: TreeData["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TreeDataComplete2.$metadata$ {
    const constructor: abstract new () => TreeDataComplete2;
}
export declare namespace TreeDataComplete2 {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class TreeDataGrowing<GN, CN extends SpptDataNode> {
    constructor(forStateSetNumber: number);
    get forStateSetNumber(): number;
    get isClean(): boolean;
    get isEmpty(): boolean;
    get complete(): TreeData;
    get growingChildren(): KtMap<GN, KtList<CN>>;
    preferred(node: CN): Nullable<CN>;
    initialise(gni: GN, initialSkipData: Nullable<TreeData>): void;
    removeTreeGrowing(node: GN): void;
    setEmbeddedChild(parent: SpptDataNode, child: SpptDataNode, embeddedTreeData: TreeData): void;
    setFirstChildForComplete(parent: CN, child: CN, isAlternative: boolean): void;
    setFirstChildForGrowing(parent: GN, child: CN): void;
    setNextChildForCompleteParent(oldParent: GN, newParent: CN, nextChild: CN, isAlternative: boolean): void;
    setNextChildForGrowingParent(oldParent: GN, newParent: GN, nextChild: CN): void;
    setSkipDataAfter(leafNodeIndex: CN, skipData: TreeData): void;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TreeDataGrowing.$metadata$ {
    const constructor: abstract new <GN, CN extends SpptDataNode>() => TreeDataGrowing<GN, CN>;
}
export declare function debug(indentDelta: Debug.IndentDelta, lazyMessage: () => string): void;
export declare abstract class Debug {
    static readonly getInstance: () => typeof Debug.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Debug.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    namespace type {
        abstract class IndentDelta {
            private constructor();
            static get NONE(): Debug.IndentDelta & {
                get name(): "NONE";
                get ordinal(): 0;
            };
            static get INC_BEFORE(): Debug.IndentDelta & {
                get name(): "INC_BEFORE";
                get ordinal(): 1;
            };
            static get INC_AFTER(): Debug.IndentDelta & {
                get name(): "INC_AFTER";
                get ordinal(): 2;
            };
            static get DEC_BEFORE(): Debug.IndentDelta & {
                get name(): "DEC_BEFORE";
                get ordinal(): 3;
            };
            static get DEC_AFTER(): Debug.IndentDelta & {
                get name(): "DEC_AFTER";
                get ordinal(): 4;
            };
            get name(): "NONE" | "INC_BEFORE" | "INC_AFTER" | "DEC_BEFORE" | "DEC_AFTER";
            get ordinal(): 0 | 1 | 2 | 3 | 4;
            static values(): Array<Debug.IndentDelta>;
            static valueOf(value: string): Debug.IndentDelta;
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace IndentDelta.$metadata$ {
            const constructor: abstract new () => IndentDelta;
        }
    }
    abstract class constructor {
        get CHECK(): boolean;
        get OUTPUT_SM_BUILD(): boolean;
        get OUTPUT_RUNTIME_BUILD(): boolean;
        get OUTPUT_RUNTIME(): boolean;
        get OUTPUT_TREE_DATA(): boolean;
        debug(indentDelta: Debug.IndentDelta, lazyMessage: () => string): void;
        private constructor();
    }
}
export declare function cached<V>(initializer: () => V): CachedValue<V>;
export declare class CachedValue<V> {
    constructor(initializer: () => V);
    get value(): V;
    set value(value: V);
    get resetAction(): (p0: V) => void;
    set resetAction(value: (p0: V) => void);
    reset(): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CachedValue.$metadata$ {
    const constructor: abstract new <V>() => CachedValue<V>;
}
export declare namespace CachedValue {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare abstract class BuildConfig {
    static readonly getInstance: () => typeof BuildConfig.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BuildConfig.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get version(): string;
        get buildStamp(): string;
        get buildDate(): string;
        get buildTime(): string;
        private constructor();
    }
}
export declare abstract class Agl {
    static readonly getInstance: () => typeof Agl.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Agl.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get version(): string;
        get buildStamp(): string;
        get registry(): LanguageRegistry;
        configurationEmpty<AsmType extends any, ContextType extends any>(): LanguageProcessorConfiguration<AsmType, ContextType>;
        configurationBase<AsmType extends any, ContextType extends any>(): LanguageProcessorConfiguration<AsmType, ContextType>;
        configurationFromLanguageObject<AsmType extends any, ContextType extends any>(languageObject: LanguageObject<AsmType, ContextType>): LanguageProcessorConfiguration<AsmType, ContextType>;
        configurationSimple(): LanguageProcessorConfiguration<Asm, SentenceContext>;
        configuration<AsmType extends any, ContextType extends any>(base: LanguageProcessorConfiguration<AsmType, ContextType> | undefined, init: (p0: LanguageProcessorConfigurationBuilder<AsmType, ContextType>) => void): LanguageProcessorConfiguration<AsmType, ContextType>;
        parseOptions(base: ParseOptions | undefined, init: (p0: ParseOptionsBuilder) => void): ParseOptions;
        options<AsmType extends any, ContextType extends any>(base: ProcessOptions<AsmType, ContextType> | undefined, init: (p0: ProcessOptionsBuilder<AsmType, ContextType>) => void): ProcessOptions<AsmType, ContextType>;
        processorFromGrammar<AsmType extends any, ContextType extends any>(grammarDomain: GrammarDomain, configuration?: Nullable<LanguageProcessorConfiguration<AsmType, ContextType>>): LanguageProcessor<AsmType, ContextType>;
        processorFromStringSimple(grammarDefinitionStr: GrammarString, typeStr?: Nullable<TypesString>, transformStr?: Nullable<AsmTransformString>, referenceStr?: Nullable<CrossReferenceString>, styleStr?: Nullable<StyleString>, formatterStr?: Nullable<FormatString>, configurationBase?: LanguageProcessorConfiguration<Asm, SentenceContext>, grammarAglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>): LanguageProcessorResult<Asm, SentenceContext>;
        processorFromStringSimpleJava(grammarDefinitionStr: string, typesStr?: Nullable<string>, asmTransformStr?: Nullable<string>, crossReferenceStr?: Nullable<string>, styleStr?: Nullable<string>, formatterStr?: Nullable<string>, configurationBase?: LanguageProcessorConfiguration<Asm, SentenceContext>, grammarAglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>): LanguageProcessorResult<Asm, SentenceContext>;
        processorFromString<AsmType extends any, ContextType extends any>(grammarDefinitionStr: string, configuration?: Nullable<LanguageProcessorConfiguration<AsmType, ContextType>>, aglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>): LanguageProcessorResult<AsmType, ContextType>;
        processorFromLanguageObject<AsmType extends any, ContextType extends any>(languageObject: LanguageObjectAbstract<AsmType, ContextType>): LanguageProcessor<AsmType, ContextType>;
        fromString<AsmType extends any, ContextType extends any>(proc: LanguageProcessor<AsmType, ContextType>, aglOptions: ProcessOptions<AsmType, ContextType>, sentence: string): ProcessResult<AsmType>;
        grammarFromString<AsmType extends any, ContextType extends any>(sentence: Nullable<string>, aglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>): ProcessResult<GrammarDomain>;
        languageDefinitionFromString<AsmType extends any, ContextType extends any>(identity: LanguageIdentity, grammarDefinitionStr?: Nullable<GrammarString>, typesStr?: Nullable<TypesString>, asmTransformStr?: Nullable<AsmTransformString>, referenceStr?: Nullable<CrossReferenceString>, styleStr?: Nullable<StyleString>, formatterStr?: Nullable<FormatString>, configurationBase?: LanguageProcessorConfiguration<AsmType, ContextType>, grammarAglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>): LanguageDefinition<AsmType, ContextType>;
        languageDefinitionFromStringSimple(identity: LanguageIdentity, grammarDefinitionStr?: Nullable<GrammarString>, typesStr?: Nullable<TypesString>, asmTransformStr?: Nullable<AsmTransformString>, referenceStr?: Nullable<CrossReferenceString>, styleStr?: Nullable<StyleString>, formatterStr?: Nullable<FormatString>, configurationBase?: LanguageProcessorConfiguration<Asm, SentenceContext>, grammarAglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>): LanguageDefinition<Asm, SentenceContext>;
        formatDomain(template: FormatString, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ProcessResult<AglFormatDomain>;
        format<SelfType extends any>(formatDomain: AglFormatDomain, objectGraph: ObjectGraphAccessorMutator, self: SelfType, options?: FormatOptions<SelfType>): FormatResult;
        formatWithTemplate<SelfType extends any>(template: FormatString, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, objectGraph: ObjectGraphAccessorMutator, self: SelfType, options?: FormatOptions<SelfType>): FormatResult;
        formatByReflection<SelfType extends any>(template: FormatString, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, self: SelfType, options?: FormatOptions<any>): FormatResult;
        executeExpression(accessorMutator: ObjectGraphAccessorMutator, self: Nullable<any>, expression: string): TypedObject;
        executeExpressionWithEvaluationContext(accessorMutator: ObjectGraphAccessorMutator, evc: EvaluationContext, expression: string): TypedObject;
        executeExpressionSuspend(accessorMutator: ObjectGraphAccessorMutator, self: Nullable<any>, expression: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
        executeExpressionWithEvaluationContextSuspend(accessorMutator: ObjectGraphAccessorMutator, evc: EvaluationContext, expression: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
        transform(m2m: M2mTransformString, typeDomains: KtMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>, accessorMutators: KtMap<SimpleName, ObjectGraphAccessorMutator>, domains: KtMap<DomainReference, KtList<TypedObject>>, targetDomainReference: DomainReference): M2MTransformResult;
        transformSuspend(m2m: M2mTransformString, typeDomains: KtMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>, accessorMutators: KtMap<SimpleName, ObjectGraphAccessorMutator>, domains: KtMap<DomainReference, KtList<TypedObject>>, targetDomainReference: DomainReference, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
        private constructor();
    }
}
export declare class Expansion {
    constructor(ruleItem: RuleItem, name: Nullable<string>, list: string);
    get ruleItem(): RuleItem;
    get name(): Nullable<string>;
    get list(): string;
    copy(ruleItem?: RuleItem, name?: Nullable<string>, list?: string): Expansion;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Expansion.$metadata$ {
    const constructor: abstract new () => Expansion;
}
export declare abstract class CompletionProviderAbstract<AsmType extends any, ContextType extends any> implements CompletionProvider<AsmType, ContextType> {
    constructor();
    provide(nextExpected: KtSet<Spine>, options: CompletionProviderOptions<ContextType>): KtList<CompletionItem>;
    readonly __doNotUseOrImplementIt: CompletionProvider<AsmType, ContextType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompletionProviderAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => CompletionProviderAbstract<AsmType, ContextType>;
}
export declare namespace CompletionProviderAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            defaultSortAndFilter(items: KtList<CompletionItem>): KtList<CompletionItem>;
            expansionToCompletionItem(expansions: KtList<Expansion>): KtList<CompletionItem>;
            provideDefaultForSpine<ContextType extends any>(spine: Spine, options: CompletionProviderOptions<ContextType>): KtList<CompletionItem>;
            provideExpansionsForSpine<ContextType extends any>(spine: Spine, options: CompletionProviderOptions<ContextType>): KtList<Expansion>;
            provideForConcatenations<ContextType extends any>(concatenations: KtSet<Concatenation>, options: CompletionProviderOptions<ContextType>): KtList<Expansion>;
            provideForRuleItems<ContextType extends any>(ruleItems: KtSet<RuleItem>, options: CompletionProviderOptions<ContextType>): KtList<Expansion>;
            provideExpansionsForRuleItem<ContextType extends any>(curDepth: number, ruleItems: KtSet<RuleItem>, options: CompletionProviderOptions<ContextType>): KtList<Expansion>;
            expand<ContextType extends any>(curDepth: number, ri: RuleItem, options: CompletionProviderOptions<ContextType>): KtList<Expansion>;
            expandItem<ContextType extends any>(curDepth: number, item: RuleItem, options: CompletionProviderOptions<ContextType>): KtList<Expansion>;
            textFor<ContextType extends any>(item: RuleItem, options: CompletionProviderOptions<ContextType>): Expansion;
            provideForTangibles<ContextType extends any>(tangibles: KtSet<TangibleItem>, options: CompletionProviderOptions<ContextType>): KtList<CompletionItem>;
            provideForTangible<ContextType extends any>(tangibleItem: TangibleItem, options: CompletionProviderOptions<ContextType>): KtList<CompletionItem>;
            private constructor();
        }
    }
}
export declare class AutomatonToKotlin {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AutomatonToKotlin.$metadata$ {
    const constructor: abstract new () => AutomatonToKotlin;
}
export declare abstract class FormatterAbstract<AsmType extends any> implements Formatter {
    constructor();
    abstract get formatDomain(): AglFormatDomain;
    abstract formatSelf(formatSetName: PossiblyQualifiedName, self: any): FormatResult;
    abstract format(formatSetName: PossiblyQualifiedName, evc: EvaluationContext): FormatResult;
    readonly __doNotUseOrImplementIt: Formatter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatterAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => FormatterAbstract<AsmType>;
}
export declare abstract class LanguageDefinitionAbstract<AsmType extends any, ContextType extends any> implements LanguageDefinition<AsmType, ContextType> {
    constructor(argGrammarDomain: GrammarDomain, argBuildForDefaultGoal: boolean);
    abstract get identity(): LanguageIdentity;
    get grammarDomain(): Nullable<GrammarDomain>;
    set grammarDomain(value: Nullable<GrammarDomain>);
    get targetGrammar(): Nullable<Grammar>;
    abstract get isModifiable(): boolean;
    get targetGrammarName(): Nullable<SimpleName>;
    set targetGrammarName(value: Nullable<SimpleName>);
    get defaultGoalRule(): Nullable<GrammarRuleName>;
    set defaultGoalRule(value: Nullable<GrammarRuleName>);
    get typesDomain(): Nullable<Domain<TypesNamespace, TypeDefinition>>/* Nullable<TypesDomain> */;
    get transformDomain(): Nullable<AsmTransformDomain>;
    get crossReferenceDomain(): Nullable<CrossReferenceDomain>;
    get syntaxAnalyser(): Nullable<SyntaxAnalyser<AsmType>>;
    get semanticAnalyser(): Nullable<SemanticAnalyser<AsmType, ContextType>>;
    get formatter(): Nullable<Formatter>;
    get issues(): IssueCollection<LanguageIssue>;
    get processor(): Nullable<LanguageProcessor<AsmType, ContextType>>;
    get styleDomain(): Nullable<AglStyleDomain>;
    get processorObservers(): KtMutableList<(p0: Nullable<LanguageProcessor<AsmType, ContextType>>, p1: Nullable<LanguageProcessor<AsmType, ContextType>>) => void>;
    get grammarStrObservers(): KtMutableList<(p0: Nullable<GrammarString>, p1: Nullable<GrammarString>) => void>;
    get grammarObservers(): KtMutableList<(p0: Nullable<GrammarDomain>, p1: Nullable<GrammarDomain>) => void>;
    get typesStrObservers(): KtMutableList<(p0: Nullable<TypesString>, p1: Nullable<TypesString>) => void>;
    get asmTransformStrObservers(): KtMutableList<(p0: Nullable<AsmTransformString>, p1: Nullable<AsmTransformString>) => void>;
    get crossReferenceStrObservers(): KtMutableList<(p0: Nullable<CrossReferenceString>, p1: Nullable<CrossReferenceString>) => void>;
    get formatterStrObservers(): KtMutableList<(p0: Nullable<FormatString>, p1: Nullable<FormatString>) => void>;
    get styleStrObservers(): KtMutableList<(p0: Nullable<StyleString>, p1: Nullable<StyleString>) => void>;
    toString(): string;
    protected get _processor_cache(): CachedValue<Nullable<LanguageProcessor<AsmType, ContextType>>>;
    protected get _style_cache(): CachedValue<Nullable<AglStyleDomain>>;
    protected get _issues(): IssueHolder;
    protected set _issues(value: IssueHolder);
    protected get _styleResolver(): Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AglStyleDomain>>;
    protected set _styleResolver(value: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AglStyleDomain>>);
    abstract get grammarString(): Nullable<GrammarString>;
    abstract get typesString(): Nullable<TypesString>;
    abstract get asmTransformString(): Nullable<AsmTransformString>;
    abstract get crossReferenceString(): Nullable<CrossReferenceString>;
    abstract get configuration(): LanguageProcessorConfiguration<AsmType, ContextType>;
    abstract set configuration(value: LanguageProcessorConfiguration<AsmType, ContextType>);
    abstract get formatString(): Nullable<FormatString>;
    abstract get styleString(): Nullable<StyleString>;
    update(grammarString?: Nullable<GrammarString>, typesString?: Nullable<TypesString>, asmTransformString?: Nullable<AsmTransformString>, crossReferenceString?: Nullable<CrossReferenceString>, styleString?: Nullable<StyleString>, formatString?: Nullable<FormatString>): void;
    readonly __doNotUseOrImplementIt: LanguageDefinition<AsmType, ContextType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageDefinitionAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => LanguageDefinitionAbstract<AsmType, ContextType>;
}
/** @deprecated Use contextFromRegistryGrammars */
export declare function contextFromGrammarRegistry(registry?: GrammarRegistry): SentenceContext;
export declare function contextFromGrammarAndTypesDomain(grammarDomain: GrammarDomain, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): SentenceContextAny;
export declare function contextFromRegistryGrammars(registry?: LanguageRegistry): SentenceContext;
export declare function contextFromRegistryTypes(registry?: LanguageRegistry): SentenceContext;
export declare function contextFromRegistryAsmTransform(registry?: LanguageRegistry): SentenceContext;
export declare function contextFromRegistryStyles(registry?: LanguageRegistry): SentenceContext;
export declare class LanguageRegistryDefault implements LanguageRegistry {
    constructor();
    get languages(): KtMap<LanguageIdentity, LanguageDefinition<any /*UnknownType **/, any /*UnknownType **/>>;
    get grammars(): KtList<Grammar>;
    get agl(): AglLanguages;
    initialise(): void;
    registerFromDefinition<AsmType extends any, ContextType extends any>(definition: LanguageDefinition<AsmType, ContextType>): LanguageDefinition<AsmType, ContextType>;
    register<AsmType extends any, ContextType extends any>(identity: LanguageIdentity, aglOptions: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>, buildForDefaultGoal: boolean, configuration: LanguageProcessorConfiguration<AsmType, ContextType>): LanguageDefinition<AsmType, ContextType>;
    registerFromLanguageObject<AsmType extends any, ContextType extends any>(languageObject: LanguageObject<AsmType, ContextType>): LanguageDefinition<AsmType, ContextType>;
    unregister(identity: LanguageIdentity): void;
    findOrNull<AsmType extends any, ContextType extends any>(identity: LanguageIdentity): Nullable<LanguageDefinition<AsmType, ContextType>>;
    findWithNamespaceOrNull<AsmType extends any, ContextType extends any>(localNamespace: string, nameOrQName: string): Nullable<LanguageDefinition<AsmType, ContextType>>;
    createLanguageDefinition<AsmType extends any, ContextType extends any>(identity: LanguageIdentity, aglOptions: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>, configuration: Nullable<LanguageProcessorConfiguration<AsmType, ContextType>>): LanguageDefinition<AsmType, ContextType>;
    findOrPlaceholder<AsmType extends any, ContextType extends any>(identity: LanguageIdentity, aglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>, configuration?: Nullable<LanguageProcessorConfiguration<AsmType, ContextType>>): LanguageDefinition<AsmType, ContextType>;
    findGrammarOrNullByQualifiedName(qualifiedName: QualifiedName): Nullable<Grammar>;
    findGrammarOrNull(localNamespace: Namespace<Grammar>, nameOrQName: PossiblyQualifiedName): Nullable<Grammar>;
    registerGrammar(grammar: Grammar): void;
    unregisterGrammar(qualifiedName: QualifiedName): void;
    readonly __doNotUseOrImplementIt: LanguageRegistry["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageRegistryDefault.$metadata$ {
    const constructor: abstract new () => LanguageRegistryDefault;
}
export declare class LanguageProcessorConfigurationBuilder<AsmType extends any, ContextType extends any> {
    constructor(base: LanguageProcessorConfiguration<AsmType, ContextType>);
    get base(): LanguageProcessorConfiguration<AsmType, ContextType>;
    targetGrammarName(value: Nullable<string>): void;
    defaultGoalRuleName(value: Nullable<string>): void;
    grammarString(value: Nullable<GrammarString>): void;
    typesString(value: Nullable<TypesString>): void;
    transformString(value: Nullable<AsmTransformString>): void;
    crossReferenceString(value: Nullable<CrossReferenceString>): void;
    styleString(value: Nullable<StyleString>): void;
    formatString(value: Nullable<FormatString>): void;
    scanner(scannerKind: ScannerKind, regexEngineKind: RegexEngineKind): void;
    scannerResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<Scanner>>): void;
    parserResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<Parser>>): void;
    transformResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AsmTransformDomain>>): void;
    typesResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>>): void;
    crossReferenceResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<CrossReferenceDomain>>): void;
    syntaxAnalyserResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<SyntaxAnalyser<AsmType>>>): void;
    syntaxAnalyserResolverResult(func: () => SyntaxAnalyser<AsmType>): void;
    semanticAnalyserResolver(value: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<SemanticAnalyser<AsmType, ContextType>>>): void;
    semanticAnalyserResolverResult(func: () => SemanticAnalyser<AsmType, ContextType>): void;
    formatResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AglFormatDomain>>): void;
    styleResolver(func: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AglStyleDomain>>): void;
    completionProvider(value: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<CompletionProvider<AsmType, ContextType>>>): void;
    build(): LanguageProcessorConfiguration<AsmType, ContextType>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageProcessorConfigurationBuilder.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => LanguageProcessorConfigurationBuilder<AsmType, ContextType>;
}
export declare class ProcessOptionsDefault<AsmType extends any, ContextType extends any> implements ProcessOptions<AsmType, ContextType> {
    constructor(scan?: ScanOptions, parse?: ParseOptions, syntaxAnalysis?: SyntaxAnalysisOptions<AsmType>, semanticAnalysis?: SemanticAnalysisOptions<ContextType>, completionProvider?: CompletionProviderOptions<ContextType>, format?: FormatOptions<AsmType>);
    get scan(): ScanOptions;
    get parse(): ParseOptions;
    get syntaxAnalysis(): SyntaxAnalysisOptions<AsmType>;
    get semanticAnalysis(): SemanticAnalysisOptions<ContextType>;
    get completionProvider(): CompletionProviderOptions<ContextType>;
    get format(): FormatOptions<AsmType>;
    clone(): ProcessOptionsDefault<AsmType, ContextType>;
    readonly __doNotUseOrImplementIt: ProcessOptions<AsmType, ContextType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ProcessOptionsDefault.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => ProcessOptionsDefault<AsmType, ContextType>;
}
export declare class SyntaxAnalysisOptionsDefault<AsmType extends any> implements SyntaxAnalysisOptions<AsmType> {
    constructor(enabled?: boolean);
    get enabled(): boolean;
    set enabled(value: boolean);
    clone(): SyntaxAnalysisOptionsDefault<AsmType>;
    readonly __doNotUseOrImplementIt: SyntaxAnalysisOptions<AsmType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalysisOptionsDefault.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => SyntaxAnalysisOptionsDefault<AsmType>;
}
export declare class SemanticAnalysisOptionsDefault<ContextType extends any> implements SemanticAnalysisOptions<ContextType> {
    constructor(enabled?: boolean, locationMap?: LocationMap, sentenceContext?: Nullable<ContextType>, buildScope?: boolean, replaceIfItemAlreadyExistsInScope?: boolean, ifItemAlreadyExistsInScopeIssueKind?: Nullable<LanguageIssueKind>, checkReferences?: boolean, resolveReferences?: boolean, other?: KtMap<string, any>);
    get enabled(): boolean;
    set enabled(value: boolean);
    get locationMap(): LocationMap;
    set locationMap(value: LocationMap);
    get sentenceContext(): Nullable<ContextType>;
    set sentenceContext(value: Nullable<ContextType>);
    get buildScope(): boolean;
    set buildScope(value: boolean);
    get replaceIfItemAlreadyExistsInScope(): boolean;
    set replaceIfItemAlreadyExistsInScope(value: boolean);
    get ifItemAlreadyExistsInScopeIssueKind(): Nullable<LanguageIssueKind>;
    set ifItemAlreadyExistsInScopeIssueKind(value: Nullable<LanguageIssueKind>);
    get checkReferences(): boolean;
    set checkReferences(value: boolean);
    get resolveReferences(): boolean;
    set resolveReferences(value: boolean);
    get other(): KtMap<string, any>;
    clone(): SemanticAnalysisOptionsDefault<ContextType>;
    readonly __doNotUseOrImplementIt: SemanticAnalysisOptions<ContextType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SemanticAnalysisOptionsDefault.$metadata$ {
    const constructor: abstract new <ContextType extends any>() => SemanticAnalysisOptionsDefault<ContextType>;
}
export declare class CompletionProviderOptionsDefault<ContextType extends any> implements CompletionProviderOptions<ContextType> {
    constructor(sentenceContext?: Nullable<ContextType>, depth?: number, path?: KtList<any/* Pair<number, number> */>, showOptionalItems?: boolean, provideValuesForPatternTerminals?: boolean, other?: KtMap<string, any>);
    get sentenceContext(): Nullable<ContextType>;
    set sentenceContext(value: Nullable<ContextType>);
    get depth(): number;
    set depth(value: number);
    get path(): KtList<any/* Pair<number, number> */>;
    set path(value: KtList<any/* Pair<number, number> */>);
    get showOptionalItems(): boolean;
    set showOptionalItems(value: boolean);
    get provideValuesForPatternTerminals(): boolean;
    set provideValuesForPatternTerminals(value: boolean);
    get other(): KtMap<string, any>;
    clone(): CompletionProviderOptionsDefault<ContextType>;
    readonly __doNotUseOrImplementIt: CompletionProviderOptions<ContextType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompletionProviderOptionsDefault.$metadata$ {
    const constructor: abstract new <ContextType extends any>() => CompletionProviderOptionsDefault<ContextType>;
}
export declare class FormatOptionsDefault<SelfType extends any> implements FormatOptions<SelfType> {
    constructor(locationMap?: Nullable<LocationMap>, environment?: KtMap<string, SelfType>);
    get locationMap(): Nullable<LocationMap>;
    set locationMap(value: Nullable<LocationMap>);
    get environment(): KtMap<string, SelfType>;
    clone(): FormatOptionsDefault<SelfType>;
    readonly __doNotUseOrImplementIt: FormatOptions<SelfType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatOptionsDefault.$metadata$ {
    const constructor: abstract new <SelfType extends any>() => FormatOptionsDefault<SelfType>;
}
export declare class ScanOptionsBuilder {
    constructor(base: ScanOptions);
    enabled(value: boolean): void;
    resultsByLine(value: boolean): void;
    build(): ScanOptions;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScanOptionsBuilder.$metadata$ {
    const constructor: abstract new () => ScanOptionsBuilder;
}
export declare class ParseOptionsBuilder {
    constructor(base: ParseOptions);
    enabled(value: boolean): void;
    goalRuleName(value: Nullable<string>): void;
    sentenceIdentity(func: SentenceIdentityFunction): void;
    reportErrors(value: boolean): void;
    reportGrammarAmbiguities(value: boolean): void;
    cacheSkip(value: boolean): void;
    reverseFindWordStartRegex(value: string): void;
    reverseFindWordStartBySkipRules(value: boolean): void;
    build(): ParseOptions;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParseOptionsBuilder.$metadata$ {
    const constructor: abstract new () => ParseOptionsBuilder;
}
export declare class ProcessOptionsBuilder<AsmType extends any, ContextType extends any> {
    constructor(base: ProcessOptions<AsmType, ContextType>);
    scan(init: (p0: ScanOptionsBuilder) => void): void;
    parse(init: (p0: ParseOptionsBuilder) => void): void;
    syntaxAnalysis(init: (p0: SyntaxAnalysisOptionsBuilder<AsmType, ContextType>) => void): void;
    semanticAnalysis(init: (p0: SemanticAnalysisOptionsBuilder<AsmType, ContextType>) => void): void;
    completionProvider(init: (p0: CompletionProviderOptionsBuilder<AsmType, ContextType>) => void): void;
    build(): ProcessOptions<AsmType, ContextType>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ProcessOptionsBuilder.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => ProcessOptionsBuilder<AsmType, ContextType>;
}
export declare class SyntaxAnalysisOptionsBuilder<AsmType extends any, ContextType extends any> {
    constructor(base: SyntaxAnalysisOptions<AsmType>);
    enabled(value: boolean): void;
    build(): SyntaxAnalysisOptions<AsmType>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalysisOptionsBuilder.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => SyntaxAnalysisOptionsBuilder<AsmType, ContextType>;
}
export declare class SemanticAnalysisOptionsBuilder<AsmType extends any, ContextType extends any> {
    constructor(base: SemanticAnalysisOptions<ContextType>);
    enabled(value: boolean): void;
    locationMap(value: LocationMap): void;
    sentenceContext(value: Nullable<ContextType>): void;
    buildScope(value: boolean): void;
    replaceIfItemAlreadyExistsInScope(value: boolean): void;
    ifItemAlreadyExistsInScopeIssueKind(value: Nullable<LanguageIssueKind>): void;
    checkReferences(value: boolean): void;
    resolveReferences(value: boolean): void;
    option(key: string, value: any): void;
    build(): SemanticAnalysisOptions<ContextType>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SemanticAnalysisOptionsBuilder.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => SemanticAnalysisOptionsBuilder<AsmType, ContextType>;
}
export declare class CompletionProviderOptionsBuilder<AsmType extends any, ContextType extends any> {
    constructor(base: CompletionProviderOptions<ContextType>);
    sentenceContext(value: Nullable<ContextType>): void;
    depth(value: number): void;
    path(value: KtList<any/* Pair<number, number> */>): void;
    showOptionalItems(value: boolean): void;
    provideValuesForPatternTerminals(value: boolean): void;
    option(key: string, value: any): void;
    build(): CompletionProviderOptions<ContextType>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompletionProviderOptionsBuilder.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => CompletionProviderOptionsBuilder<AsmType, ContextType>;
}
export declare class LanguageProcessorResult<AsmType extends any, ContextType extends any> {
    constructor(processor: Nullable<LanguageProcessor<AsmType, ContextType>>, issues: IssueCollection<LanguageIssue>);
    get processor(): Nullable<LanguageProcessor<AsmType, ContextType>>;
    get issues(): IssueCollection<LanguageIssue>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageProcessorResult.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => LanguageProcessorResult<AsmType, ContextType>;
}
export declare class SyntaxAnalysisResultDefault<AsmType extends any> implements SyntaxAnalysisResult<AsmType> {
    constructor(asm: Nullable<AsmType>, issues: IssueCollection<LanguageIssue>, locationMap: LocationMap);
    get asm(): Nullable<AsmType>;
    get issues(): IssueCollection<LanguageIssue>;
    get locationMap(): LocationMap;
    copy(asm?: Nullable<AsmType>, issues?: IssueCollection<LanguageIssue>, locationMap?: LocationMap): SyntaxAnalysisResultDefault<AsmType>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: SyntaxAnalysisResult<AsmType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalysisResultDefault.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => SyntaxAnalysisResultDefault<AsmType>;
}
export declare class SemanticAnalysisResultDefault implements SemanticAnalysisResult {
    constructor(resolvedReferences: KtList<ResolvedReference>, issues: IssueCollection<LanguageIssue>);
    get resolvedReferences(): KtList<ResolvedReference>;
    get issues(): IssueCollection<LanguageIssue>;
    copy(resolvedReferences?: KtList<ResolvedReference>, issues?: IssueCollection<LanguageIssue>): SemanticAnalysisResultDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: SemanticAnalysisResult["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SemanticAnalysisResultDefault.$metadata$ {
    const constructor: abstract new () => SemanticAnalysisResultDefault;
}
export declare class ProcessResultDefault<AsmType extends any> implements ProcessResult<AsmType> {
    constructor(asm: Nullable<AsmType>, parse?: Nullable<ParseResult>, syntaxAnalysis?: Nullable<SyntaxAnalysisResult<AsmType>>, semanticAnalysis?: Nullable<SemanticAnalysisResult>, processIssues?: IssueCollection<LanguageIssue>);
    get asm(): Nullable<AsmType>;
    get parse(): Nullable<ParseResult>;
    get syntaxAnalysis(): Nullable<SyntaxAnalysisResult<AsmType>>;
    get semanticAnalysis(): Nullable<SemanticAnalysisResult>;
    get processIssues(): IssueCollection<LanguageIssue>;
    get allIssues(): IssueCollection<LanguageIssue>;
    copy(asm?: Nullable<AsmType>, parse?: Nullable<ParseResult>, syntaxAnalysis?: Nullable<SyntaxAnalysisResult<AsmType>>, semanticAnalysis?: Nullable<SemanticAnalysisResult>, processIssues?: IssueCollection<LanguageIssue>): ProcessResultDefault<AsmType>;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ProcessResult<AsmType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ProcessResultDefault.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => ProcessResultDefault<AsmType>;
}
export declare class FormatResultDefault implements FormatResult {
    constructor(output: KtMap<string, string>, issues: IssueCollection<LanguageIssue>);
    get output(): KtMap<string, string>;
    get issues(): IssueCollection<LanguageIssue>;
    get sentence(): Nullable<string>;
    copy(output?: KtMap<string, string>, issues?: IssueCollection<LanguageIssue>): FormatResultDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: FormatResult["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatResultDefault.$metadata$ {
    const constructor: abstract new () => FormatResultDefault;
}
export declare namespace FormatResultDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get DEFAULT(): string;
            private constructor();
        }
    }
}
export declare class ExpectedAtResultDefault implements ExpectedAtResult {
    constructor(requestedPosition: number, offeredPosition: number, items: KtList<CompletionItem>, issues: IssueCollection<LanguageIssue>);
    get requestedPosition(): number;
    get offeredPosition(): number;
    get items(): KtList<CompletionItem>;
    get issues(): IssueCollection<LanguageIssue>;
    get isTerminalCompletion(): boolean;
    get offset(): number;
    copy(requestedPosition?: number, offeredPosition?: number, items?: KtList<CompletionItem>, issues?: IssueCollection<LanguageIssue>): ExpectedAtResultDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ExpectedAtResult["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpectedAtResultDefault.$metadata$ {
    const constructor: abstract new () => ExpectedAtResultDefault;
}
export declare function contextFromTypesDomain(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): SentenceContext;
export declare class CompletionProviderSimple extends CompletionProviderAbstract.$metadata$.constructor<Asm, SentenceContext> {
    constructor(targetGrammar: Grammar, grammar2TypesDomain: Grammar2TypesDomainMapping, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, crossReferenceDomain: CrossReferenceDomain);
    get targetGrammar(): Grammar;
    get grammar2TypesDomain(): Grammar2TypesDomainMapping;
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get crossReferenceDomain(): CrossReferenceDomain;
    get targetNamespace(): GrammarTypesNamespaceSimple;
    provide(nextExpected: KtSet<Spine>, options: CompletionProviderOptions<SentenceContext>): KtList<CompletionItem>;
    typeFor(rule: GrammarRule): Nullable<TypeInstance>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompletionProviderSimple.$metadata$ {
    const constructor: abstract new () => CompletionProviderSimple;
}
export declare class CreateScopedItemDefault implements CreateScopedItem {
    constructor();
    invoke(qualifiedName: KtList<string>, item: any, location: Nullable<InputLocation>): any;
    readonly __doNotUseOrImplementIt: CreateScopedItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CreateScopedItemDefault.$metadata$ {
    const constructor: abstract new () => CreateScopedItemDefault;
}
export declare class ResolveScopedItemDefault implements ResolveScopedItem {
    constructor();
    invoke(itemInScope: any): Nullable<any>;
    readonly __doNotUseOrImplementIt: ResolveScopedItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ResolveScopedItemDefault.$metadata$ {
    const constructor: abstract new () => ResolveScopedItemDefault;
}
export declare class SentenceContextAny implements SentenceContext {
    constructor(createScopedItem?: CreateScopedItem, resolveScopedItem?: ResolveScopedItem);
    get createScopedItem(): CreateScopedItem;
    get resolveScopedItem(): ResolveScopedItem;
    get scopeForSentence(): KtMutableMap<any, ScopeSimple>;
    get isEmpty(): boolean;
    clear(): void;
    newScopeForSentence(sentenceIdentity: Nullable<any>): Scope;
    getScopeForSentenceOrNull(sentenceIdentity: Nullable<any>): Nullable<Scope>;
    getOrCreateScopeForSentence(sentenceIdentity: Nullable<any>): Scope;
    addToScope(sentenceIdentity: Nullable<any>, qualifiedName: KtList<string>, itemTypeName: QualifiedName, location: Nullable<InputLocation>, item: any): void;
    merge(sentenceIdentity: Nullable<any>, other: Scope): void;
    findItemsConformingTo(conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsNamedConformingTo(name: string, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsByQualifiedNameConformingTo(qname: KtList<string>, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    union(other: SentenceContext): SentenceContext;
    asString(indent?: Indent): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: SentenceContext["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SentenceContextAny.$metadata$ {
    const constructor: abstract new () => SentenceContextAny;
}
export declare namespace SentenceContextAny {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        namespace type {
            abstract class NULL_SENTENCE_IDENTIFIER {
                static readonly getInstance: () => typeof NULL_SENTENCE_IDENTIFIER.$metadata$.type;
                private constructor();
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace NULL_SENTENCE_IDENTIFIER.$metadata$ {
                abstract class type extends KtSingleton<constructor>() {
                    private constructor();
                }
                abstract class constructor {
                    toString(): string;
                    private constructor();
                }
            }
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class ReferenceExpressionContext {
    constructor(element: AsmValue, scope: Scope);
    get element(): AsmValue;
    get scope(): Scope;
    copy(element?: AsmValue, scope?: Scope): ReferenceExpressionContext;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceExpressionContext.$metadata$ {
    const constructor: abstract new () => ReferenceExpressionContext;
}
export declare class ReferenceResolverSimple implements AsmTreeWalker {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, crossReferenceDomain: CrossReferenceDomain, sentenceContext: SentenceContext, sentenceIdentity: Nullable<any>, identifyingValueInFor: (p0: SimpleName, p1: AsmStructure) => Nullable<any>, resolveFunction: Nullable<ResolveScopedItem>, _locationMap: LocationMap, _issues: IssueHolder);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get crossReferenceDomain(): CrossReferenceDomain;
    get sentenceContext(): SentenceContext;
    get sentenceIdentity(): Nullable<any>;
    get identifyingValueInFor(): (p0: SimpleName, p1: AsmStructure) => Nullable<any>;
    get resolveFunction(): Nullable<ResolveScopedItem>;
    get resolvedReferences(): KtMutableList<ResolvedReference>;
    beforeRoot(root: AsmValue): void;
    afterRoot(root: AsmValue): void;
    onNothing(owningProperty: Nullable<AsmStructureProperty>, value: AsmNothing): void;
    onPrimitive(owningProperty: Nullable<AsmStructureProperty>, value: AsmPrimitive): void;
    beforeStructure(owningProperty: Nullable<AsmStructureProperty>, value: AsmStructure): void;
    onProperty(owner: AsmStructure, property: AsmStructureProperty): void;
    afterStructure(owningProperty: Nullable<AsmStructureProperty>, value: AsmStructure): void;
    beforeList(owningProperty: Nullable<AsmStructureProperty>, value: AsmList): void;
    afterList(owningProperty: Nullable<AsmStructureProperty>, value: AsmList): void;
    readonly __doNotUseOrImplementIt: AsmTreeWalker["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceResolverSimple.$metadata$ {
    const constructor: abstract new () => ReferenceResolverSimple;
}
export declare class ScopeCreator implements AsmTreeWalker {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, crossReferenceDomain: CrossReferenceDomain, context: SentenceContext, sentenceIdentity: Nullable<any>, replaceIfItemAlreadyExistsInScope: boolean, ifItemAlreadyExistsInScopeIssueKind: Nullable<LanguageIssueKind>, identifyingValueInFor: (p0: SimpleName, p1: AsmStructure) => Nullable<any>, locationMap: LocationMap, issues: IssueHolder);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get crossReferenceDomain(): CrossReferenceDomain;
    get context(): SentenceContext;
    get sentenceIdentity(): Nullable<any>;
    get replaceIfItemAlreadyExistsInScope(): boolean;
    set replaceIfItemAlreadyExistsInScope(value: boolean);
    get ifItemAlreadyExistsInScopeIssueKind(): Nullable<LanguageIssueKind>;
    set ifItemAlreadyExistsInScopeIssueKind(value: Nullable<LanguageIssueKind>);
    get identifyingValueInFor(): (p0: SimpleName, p1: AsmStructure) => Nullable<any>;
    get locationMap(): LocationMap;
    get issues(): IssueHolder;
    get currentScope(): any/* MutableStack<Scope> */;
    beforeRoot(root: AsmValue): void;
    afterRoot(root: AsmValue): void;
    onNothing(owningProperty: Nullable<AsmStructureProperty>, value: AsmNothing): void;
    onPrimitive(owningProperty: Nullable<AsmStructureProperty>, value: AsmPrimitive): void;
    beforeStructure(owningProperty: Nullable<AsmStructureProperty>, value: AsmStructure): void;
    onProperty(owner: AsmStructure, property: AsmStructureProperty): void;
    afterStructure(owningProperty: Nullable<AsmStructureProperty>, value: AsmStructure): void;
    beforeList(owningProperty: Nullable<AsmStructureProperty>, value: AsmList): void;
    afterList(owningProperty: Nullable<AsmStructureProperty>, value: AsmList): void;
    readonly __doNotUseOrImplementIt: AsmTreeWalker["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScopeCreator.$metadata$ {
    const constructor: abstract new () => ScopeCreator;
}
export declare class SemanticAnalyserSimple implements SemanticAnalyser<Asm, SentenceContext> {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, crossReferenceDomain: CrossReferenceDomain);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get crossReferenceDomain(): CrossReferenceDomain;
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: Asm, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<Asm, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SemanticAnalyserSimple.$metadata$ {
    const constructor: abstract new () => SemanticAnalyserSimple;
}
export declare namespace SemanticAnalyserSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            identifyingValueInFor(interpreter: ExpressionsInterpreterOverTypedObject, crossReferenceDomain: CrossReferenceDomain, inScopeForTypeName: SimpleName, self: AsmStructure): Nullable<any>;
            private constructor();
        }
    }
}
export declare class SyntaxAnalyserSimple extends SyntaxAnalyserFromAsmTransformAbstract.$metadata$.constructor<Asm, AsmValue> {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, asmTransformDomain: AsmTransformDomain, relevantTrRuleSet: QualifiedName);
    constructAsm(): Asm;
    rootList(asm: Asm): KtList<AsmValue>;
    addAsmRoot(asm: Asm, root: AsmValue): boolean;
    removeAsmRoot(asm: Asm, root: AsmValue): boolean;
    get embeddedSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<Asm>>;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalyserSimple.$metadata$ {
    const constructor: abstract new () => SyntaxAnalyserSimple;
}
export declare interface Grammar2TypesDomainMapping {
    typeNameFor(rule: GrammarRule): SimpleName;
    propertyNameFor(context: Grammar, ruleItem: RuleItem, ruleItemType: TypeDefinition): PropertyName;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.agl.simple.Grammar2TypesDomainMapping": unique symbol;
    };
}
export declare function lower(_this_: string): string;
export declare class TypesDomainFromGrammarConfigurationDefault implements Grammar2TypesDomainMapping {
    constructor();
    typeNameFor(rule: GrammarRule): SimpleName;
    propertyNameFor(context: Grammar, ruleItem: RuleItem, ruleItemType: TypeDefinition): PropertyName;
    readonly __doNotUseOrImplementIt: Grammar2TypesDomainMapping["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypesDomainFromGrammarConfigurationDefault.$metadata$ {
    const constructor: abstract new () => TypesDomainFromGrammarConfigurationDefault;
}
export declare function contextAsmSimple(createScopedItem?: CreateScopedItem, resolveScopedItem?: ResolveScopedItem, init?: (p0: ContextBuilder) => void): SentenceContext;
export declare function contextAsmSimpleWithAsmPath(map?: KtMutableMap<string, any>, init?: (p0: ContextBuilder) => void): SentenceContext;
export declare class ContextBuilder {
    constructor(createScopedItem: CreateScopedItem, resolveScopedItem: ResolveScopedItem);
    forSentence(id: Nullable<any>, init?: (p0: ScopeBuilder) => void): void;
    build(): SentenceContext;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ContextBuilder.$metadata$ {
    const constructor: abstract new () => ContextBuilder;
}
export declare class ScopeBuilder {
    constructor(_scope: ScopeSimple, _createScopedItem: CreateScopedItem, _resolveScopedItem: ResolveScopedItem);
    item(id: string, qualifiedTypeName: string, location: Nullable<any>, itemInScope: any): void;
    scope(forReferenceInParent: string, forTypeName: string, init?: (p0: ScopeBuilder) => void): void;
    scopedItem(id: string, qualifiedTypeName: string, location: Nullable<any>, itemInScope: any, init?: (p0: ScopeBuilder) => void): void;
    build(): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScopeBuilder.$metadata$ {
    const constructor: abstract new () => ScopeBuilder;
}
export declare abstract class SyntaxAnalyserByMethodRegistrationAbstract<AsmType extends any> extends SyntaxAnalyserFromTreeDataAbstract.$metadata$.constructor<AsmType> {
    constructor();
    abstract registerHandlers(): void;
    get asm(): AsmType;
    walkTree(sentence: Sentence, treeData: TreeData, skipDataAsTree: boolean): void;
    protected register<T>(handler: any/* KFunction3<SpptDataNodeInfo, KtList<Nullable<any>>, Sentence, Nullable<T>> */): void;
    protected registerFor<T>(branchName: string, handler: any/* KFunction3<SpptDataNodeInfo, KtList<Nullable<any>>, Sentence, Nullable<T>> */): void;
    protected registerForBeginHandler<T>(branchName: string, handler: any/* KFunction3<SpptDataNodeInfo, KtList<Nullable<any>>, Sentence, Nullable<T>> */): void;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalyserByMethodRegistrationAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => SyntaxAnalyserByMethodRegistrationAbstract<AsmType>;
}
export declare namespace SyntaxAnalyserByMethodRegistrationAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class NodeTrRules {
    constructor(forNode: AsmTransformationRule, forChildren: AsmTransformationRule);
    get forNode(): AsmTransformationRule;
    get forChildren(): AsmTransformationRule;
    static new_net_akehurst_language_agl_syntaxAnalyser_NodeTrRules(t: AsmTransformationRule): NodeTrRules;
    copy(forNode?: AsmTransformationRule, forChildren?: AsmTransformationRule): NodeTrRules;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NodeTrRules.$metadata$ {
    const constructor: abstract new () => NodeTrRules;
}
export declare class DownData2 {
    constructor(path: ParsePath, trRule: NodeTrRules);
    get path(): ParsePath;
    get trRule(): NodeTrRules;
    copy(path?: ParsePath, trRule?: NodeTrRules): DownData2;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DownData2.$metadata$ {
    const constructor: abstract new () => DownData2;
}
export declare class ChildData {
    constructor(nodeInfo: SpptDataNodeInfo, value: Nullable<TypedObject>);
    get nodeInfo(): SpptDataNodeInfo;
    get value(): Nullable<TypedObject>;
    copy(nodeInfo?: SpptDataNodeInfo, value?: Nullable<TypedObject>): ChildData;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChildData.$metadata$ {
    const constructor: abstract new () => ChildData;
}
export declare abstract class SyntaxAnalyserFromAsmTransformAbstract<AsmType extends any, AsmValueType extends any> extends SyntaxAnalyserFromTreeDataAbstract.$metadata$.constructor<AsmType> {
    constructor(_typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, asmTransform: AsmTransformDomain, relevantTrRuleSet: QualifiedName, objectGraph: ObjectGraphAccessorMutator);
    get asmTransform(): AsmTransformDomain;
    get relevantTrRuleSet(): QualifiedName;
    get objectGraph(): ObjectGraphAccessorMutator;
    abstract constructAsm(): AsmType;
    abstract rootList(asm: AsmType): KtList<AsmValueType>;
    abstract addAsmRoot(asm: AsmType, rootValue: AsmValueType): boolean;
    abstract removeAsmRoot(asm: AsmType, rootValue: AsmValueType): boolean;
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get asm(): AsmType;
    get relevantRuleSet(): AsmTransformRuleSet;
    get _trf(): AsmTransformInterpreter;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
    walkTree(sentence: Sentence, treeData: TreeData, skipDataAsTree: boolean): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalyserFromAsmTransformAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any, AsmValueType extends any>() => SyntaxAnalyserFromAsmTransformAbstract<AsmType, AsmValueType>;
}
export declare namespace SyntaxAnalyserFromAsmTransformAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get CONFIGURATION_KEY_AGL_SCOPE_MODEL(): string;
            private constructor();
        }
    }
}
export declare class LocationMapDefault implements LocationMap {
    constructor();
    clear(): void;
    get(obj: Nullable<any>): Nullable<InputLocation>;
    getByPath(obj: Nullable<any>, path: ParsePath): Nullable<InputLocation>;
    add(path: ParsePath, obj: any, location: InputLocation): void;
    readonly __doNotUseOrImplementIt: LocationMap["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LocationMapDefault.$metadata$ {
    const constructor: abstract new () => LocationMapDefault;
}
export declare abstract class SyntaxAnalyserFromTreeDataAbstract<AsmType extends any> implements SyntaxAnalyser<AsmType> {
    constructor();
    get locationMap(): LocationMapDefault;
    get issues(): IssueHolder;
    abstract get asm(): AsmType;
    get extendsSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    get embeddedSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    setLocationFor(obj: any, nodeInfo: SpptDataNodeInfo, sentence: Sentence): void;
    setEmbeddedSyntaxAnalyser(qualifiedName: QualifiedName, sa: SyntaxAnalyser<AsmType>): void;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
    transform(sppt: SharedPackedParseTree): SyntaxAnalysisResult<AsmType>;
    abstract walkTree(sentence: Sentence, treeData: TreeData, skipDataAsTree: boolean): void;
    locationForNode(sentence: Sentence, node: SpptDataNode): InputLocation;
    readonly __doNotUseOrImplementIt: SyntaxAnalyser<AsmType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalyserFromTreeDataAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => SyntaxAnalyserFromTreeDataAbstract<AsmType>;
}
export declare class SyntaxAnalyserGeneratorKotlin {
    constructor();
    generateFor(grammar: Grammar): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalyserGeneratorKotlin.$metadata$ {
    const constructor: abstract new () => SyntaxAnalyserGeneratorKotlin;
}
export declare class NodeTypes {
    constructor(forNode: TypeInstance, forChildren: TypeInstance);
    get forNode(): TypeInstance;
    get forChildren(): TypeInstance;
    static new_net_akehurst_language_agl_syntaxAnalyser_NodeTypes(t: TypeInstance): NodeTypes;
    copy(forNode?: TypeInstance, forChildren?: TypeInstance): NodeTypes;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NodeTypes.$metadata$ {
    const constructor: abstract new () => NodeTypes;
}
export declare class DownData {
    constructor(path: AsmPath, typeUse: NodeTypes);
    get path(): AsmPath;
    get typeUse(): NodeTypes;
    copy(path?: AsmPath, typeUse?: NodeTypes): DownData;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DownData.$metadata$ {
    const constructor: abstract new () => DownData;
}
export declare class ChildDataAny {
    constructor(nodeInfo: SpptDataNodeInfo, value: Nullable<any>);
    get nodeInfo(): SpptDataNodeInfo;
    get value(): Nullable<any>;
    copy(nodeInfo?: SpptDataNodeInfo, value?: Nullable<any>): ChildDataAny;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChildDataAny.$metadata$ {
    const constructor: abstract new () => ChildDataAny;
}
export declare abstract class SyntaxAnalyserSimpleStreamPushAbstract<AsmType extends any> extends SyntaxAnalyserFromTreeDataAbstract.$metadata$.constructor<AsmType> {
    constructor(grammarNamespaceQualifiedName: QualifiedName, types: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, crossReference: CrossReferenceDomain);
    get grammarNamespaceQualifiedName(): QualifiedName;
    get types(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get crossReference(): CrossReferenceDomain;
    abstract startAsm(): void;
    abstract finishAsm(): void;
    abstract primitive(type: PrimitiveType, value: Nullable<string>): void;
    abstract startList(): void;
    abstract finishList(): void;
    abstract startListSeparated(): void;
    abstract finishListSeparated(): void;
    abstract listElement(): void;
    abstract startAsmElement(path: AsmPath, type: DataType): void;
    abstract finishAsmElement(path: AsmPath, type: DataType): void;
    abstract startTuple(): void;
    abstract finishTuple(path: AsmPath): void;
    abstract startProperty(declaration: PropertyDeclaration, isRef: boolean): void;
    abstract finishProperty(declaration: PropertyDeclaration, isRef: boolean): void;
    walkTree(sentence: Sentence, treeData: TreeData, skipDataAsTree: boolean): void;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SyntaxAnalyserSimpleStreamPushAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any>() => SyntaxAnalyserSimpleStreamPushAbstract<AsmType>;
}
export declare namespace SyntaxAnalyserSimpleStreamPushAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get CONFIGURATION_KEY_AGL_SCOPE_MODEL(): string;
            private constructor();
        }
    }
}
export declare interface AsmWalker<AsmType extends any, AsmValueType extends any, AsmStructureType extends AsmValueType, PropertyType, ListValueType> {
    beforeRoot(root: AsmValueType): void;
    afterRoot(root: AsmValueType): void;
    onNothing(owningProperty: Nullable<PropertyType>, value: AsmValueType): void;
    onPrimitive(owningProperty: Nullable<PropertyType>, value: AsmValueType): void;
    beforeStructure(owningProperty: Nullable<PropertyType>, value: AsmStructureType): void;
    onProperty(owner: AsmStructureType, property: PropertyType): void;
    afterStructure(owningProperty: Nullable<PropertyType>, value: AsmStructureType): void;
    beforeList(owningProperty: Nullable<PropertyType>, value: ListValueType): void;
    afterList(owningProperty: Nullable<PropertyType>, value: ListValueType): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.syntaxAnalyser.AsmWalker": unique symbol;
    };
}
export declare interface LocationMap {
    clear(): void;
    add(path: ParsePath, obj: any, location: InputLocation): void;
    get(obj: Nullable<any>): Nullable<InputLocation>;
    getByPath(obj: Nullable<any>, path: ParsePath): Nullable<InputLocation>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.syntaxAnalyser.LocationMap": unique symbol;
    };
}
export declare interface SyntaxAnalyser<AsmType extends any> {
    readonly locationMap: LocationMap;
    readonly extendsSyntaxAnalyser: KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    readonly embeddedSyntaxAnalyser: KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
    transform(sppt: SharedPackedParseTree): SyntaxAnalysisResult<AsmType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.syntaxAnalyser.SyntaxAnalyser": unique symbol;
    };
}
export declare abstract class CompletionItemKind {
    private constructor();
    static get PATTERN(): CompletionItemKind & {
        get name(): "PATTERN";
        get ordinal(): 0;
    };
    static get LITERAL(): CompletionItemKind & {
        get name(): "LITERAL";
        get ordinal(): 1;
    };
    static get SEGMENT(): CompletionItemKind & {
        get name(): "SEGMENT";
        get ordinal(): 2;
    };
    static get REFERRED(): CompletionItemKind & {
        get name(): "REFERRED";
        get ordinal(): 3;
    };
    get name(): "PATTERN" | "LITERAL" | "SEGMENT" | "REFERRED";
    get ordinal(): 0 | 1 | 2 | 3;
    static values(): Array<CompletionItemKind>;
    static valueOf(value: string): CompletionItemKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompletionItemKind.$metadata$ {
    const constructor: abstract new () => CompletionItemKind;
}
export declare class CompletionItem {
    constructor(kind: CompletionItemKind, label: string, text: string);
    get kind(): CompletionItemKind;
    get label(): string;
    get text(): string;
    get id(): Nullable<number>;
    set id(value: Nullable<number>);
    get description(): string;
    set description(value: string);
    get detail(): Nullable<RuleItem>;
    set detail(value: Nullable<RuleItem>);
    copy(kind?: CompletionItemKind, label?: string, text?: string): CompletionItem;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CompletionItem.$metadata$ {
    const constructor: abstract new () => CompletionItem;
}
export declare interface SpineNode {
    readonly rule: GrammarRule;
    readonly nextChildNumber: number;
    readonly nextExpectedItems: KtSet<RuleItem>;
    readonly nextExpectedConcatenation: KtSet<Concatenation>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.SpineNode": unique symbol;
    };
}
export declare interface Spine {
    readonly expectedNextLeafNonTerminalOrTerminal: KtSet<TangibleItem>;
    readonly expectedNextRuleItems: KtSet<RuleItem>;
    readonly elements: KtList<SpineNode>;
    readonly nextChildNumber: number;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.Spine": unique symbol;
    };
}
export declare interface CompletionProvider<AsmType extends any, ContextType extends any> {
    provide(nextExpected: KtSet<Spine>, options: CompletionProviderOptions<ContextType>): KtList<CompletionItem>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.CompletionProvider": unique symbol;
    };
}
export declare interface Formatter {
    readonly formatDomain: AglFormatDomain;
    formatSelf(formatSetName: PossiblyQualifiedName, self: any): FormatResult;
    format(formatSetName: PossiblyQualifiedName, evc: EvaluationContext): FormatResult;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.Formatter": unique symbol;
    };
}
export declare interface GrammarRegistry {
    readonly grammars: KtList<Grammar>;
    registerGrammar(grammar: Grammar): void;
    findGrammarOrNull(localNamespace: Namespace<Grammar>, nameOrQName: PossiblyQualifiedName): Nullable<Grammar>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.GrammarRegistry": unique symbol;
    };
}
export declare class LanguageIdentity implements PublicValueType {
    constructor(value: string);
    get value(): string;
    get last(): string;
    copy(value?: string): LanguageIdentity;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageIdentity.$metadata$ {
    const constructor: abstract new () => LanguageIdentity;
}
export declare class GrammarString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): GrammarString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarString.$metadata$ {
    const constructor: abstract new () => GrammarString;
}
export declare class TypesString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): TypesString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypesString.$metadata$ {
    const constructor: abstract new () => TypesString;
}
export declare class AsmTransformString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): AsmTransformString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformString.$metadata$ {
    const constructor: abstract new () => AsmTransformString;
}
export declare class CrossReferenceString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): CrossReferenceString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CrossReferenceString.$metadata$ {
    const constructor: abstract new () => CrossReferenceString;
}
export declare class StyleString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): StyleString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleString.$metadata$ {
    const constructor: abstract new () => StyleString;
}
export declare class FormatString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): FormatString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatString.$metadata$ {
    const constructor: abstract new () => FormatString;
}
export declare class M2mTransformString implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): M2mTransformString;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformString.$metadata$ {
    const constructor: abstract new () => M2mTransformString;
}
export declare interface LanguageRegistry extends GrammarRegistry {
    readonly agl: AglLanguages;
    readonly languages: KtMap<LanguageIdentity, LanguageDefinition<any /*UnknownType **/, any /*UnknownType **/>>;
    initialise(): void;
    register<AsmType extends any, ContextType extends any>(identity: LanguageIdentity, aglOptions: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>, buildForDefaultGoal: boolean, configuration: LanguageProcessorConfiguration<AsmType, ContextType>): LanguageDefinition<AsmType, ContextType>;
    unregister(identity: LanguageIdentity): void;
    findOrNull<AsmType extends any, ContextType extends any>(identity: LanguageIdentity): Nullable<LanguageDefinition<AsmType, ContextType>>;
    findOrPlaceholder<AsmType extends any, ContextType extends any>(identity: LanguageIdentity, aglOptions?: Nullable<ProcessOptions<GrammarDomain, SentenceContext>>, configuration?: Nullable<LanguageProcessorConfiguration<AsmType, ContextType>>): LanguageDefinition<AsmType, ContextType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.LanguageRegistry": unique symbol;
    } & GrammarRegistry["__doNotUseOrImplementIt"];
}
export declare interface AglLanguages {
    readonly baseLanguageIdentity: LanguageIdentity;
    readonly expressionsLanguageIdentity: LanguageIdentity;
    readonly grammarLanguageIdentity: LanguageIdentity;
    readonly typesLanguageIdentity: LanguageIdentity;
    readonly crossReferenceLanguageIdentity: LanguageIdentity;
    readonly asmTransformLanguageIdentity: LanguageIdentity;
    readonly m2mTransformLanguageIdentity: LanguageIdentity;
    readonly styleLanguageIdentity: LanguageIdentity;
    readonly formatLanguageIdentity: LanguageIdentity;
    readonly base: LanguageDefinition<any, SentenceContext>;
    readonly expressions: LanguageDefinition<Expression, SentenceContext>;
    readonly grammar: LanguageDefinition<GrammarDomain, SentenceContext>;
    readonly types: LanguageDefinition<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, SentenceContext>;
    readonly crossReference: LanguageDefinition<CrossReferenceDomain, SentenceContext>;
    readonly asmTransform: LanguageDefinition<AsmTransformDomain, SentenceContext>;
    readonly m2mTransform: LanguageDefinition<M2mTransformDomain, SentenceContext>;
    readonly style: LanguageDefinition<AglStyleDomain, SentenceContext>;
    readonly format: LanguageDefinition<AglFormatDomain, SentenceContext>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.AglLanguages": unique symbol;
    };
}
export declare interface LanguageDefinition<AsmType extends any, ContextType extends any> {
    readonly identity: LanguageIdentity;
    readonly isModifiable: boolean;
    readonly grammarString: Nullable<GrammarString>;
    readonly grammarDomain: Nullable<GrammarDomain>;
    readonly targetGrammar: Nullable<Grammar>;
    readonly targetGrammarName: Nullable<SimpleName>;
    readonly defaultGoalRule: Nullable<GrammarRuleName>;
    readonly typesString: Nullable<TypesString>;
    readonly typesDomain: Nullable<Domain<TypesNamespace, TypeDefinition>>/* Nullable<TypesDomain> */;
    readonly asmTransformString: Nullable<AsmTransformString>;
    readonly transformDomain: Nullable<AsmTransformDomain>;
    readonly crossReferenceString: Nullable<CrossReferenceString>;
    readonly crossReferenceDomain: Nullable<CrossReferenceDomain>;
    configuration: LanguageProcessorConfiguration<AsmType, ContextType>;
    readonly syntaxAnalyser: Nullable<SyntaxAnalyser<AsmType>>;
    readonly semanticAnalyser: Nullable<SemanticAnalyser<AsmType, ContextType>>;
    readonly formatString: Nullable<FormatString>;
    readonly formatter: Nullable<Formatter>;
    readonly processor: Nullable<LanguageProcessor<AsmType, ContextType>>;
    readonly styleString: Nullable<StyleString>;
    readonly styleDomain: Nullable<AglStyleDomain>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly processorObservers: KtMutableList<(p0: Nullable<LanguageProcessor<AsmType, ContextType>>, p1: Nullable<LanguageProcessor<AsmType, ContextType>>) => void>;
    readonly grammarStrObservers: KtMutableList<(p0: Nullable<GrammarString>, p1: Nullable<GrammarString>) => void>;
    readonly grammarObservers: KtMutableList<(p0: Nullable<GrammarDomain>, p1: Nullable<GrammarDomain>) => void>;
    readonly typesStrObservers: KtMutableList<(p0: Nullable<TypesString>, p1: Nullable<TypesString>) => void>;
    readonly asmTransformStrObservers: KtMutableList<(p0: Nullable<AsmTransformString>, p1: Nullable<AsmTransformString>) => void>;
    readonly crossReferenceStrObservers: KtMutableList<(p0: Nullable<CrossReferenceString>, p1: Nullable<CrossReferenceString>) => void>;
    readonly formatterStrObservers: KtMutableList<(p0: Nullable<FormatString>, p1: Nullable<FormatString>) => void>;
    readonly styleStrObservers: KtMutableList<(p0: Nullable<StyleString>, p1: Nullable<StyleString>) => void>;
    update(grammarString?: Nullable<GrammarString>, typesString?: Nullable<TypesString>, asmTransformString?: Nullable<AsmTransformString>, crossReferenceString?: Nullable<CrossReferenceString>, styleString?: Nullable<StyleString>, formatString?: Nullable<FormatString>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.LanguageDefinition": unique symbol;
    };
}
export declare interface LanguageProcessor<AsmType extends any, ContextType extends any> {
    readonly configuration: LanguageProcessorConfiguration<AsmType, ContextType>;
    readonly allIssues: IssueCollection<LanguageIssue>;
    readonly grammarDomain: Nullable<GrammarDomain>;
    readonly targetGrammar: Nullable<Grammar>;
    readonly ruleSets: KtMap<string, RuleSet>;
    readonly targetRuleSet: Nullable<RuleSet>;
    readonly scanner: Nullable<Scanner>;
    readonly spptParser: SPPTParser;
    readonly parser: Nullable<Parser>;
    readonly baseTypesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    readonly typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    readonly transformDomain: AsmTransformDomain;
    readonly targetTransformRuleSet: AsmTransformRuleSet;
    readonly crossReferenceDomain: CrossReferenceDomain;
    readonly formatDomain: Nullable<AglFormatDomain>;
    readonly syntaxAnalyser: Nullable<SyntaxAnalyser<AsmType>>;
    readonly semanticAnalyser: Nullable<SemanticAnalyser<AsmType, ContextType>>;
    readonly formatter: Nullable<Formatter>;
    readonly completionProvider: Nullable<CompletionProvider<AsmType, ContextType>>;
    interrupt(message: string): void;
    parseOptionsDefault(): ParseOptions;
    optionsDefault(): ProcessOptions<AsmType, ContextType>;
    clear(): void;
    buildFor(options?: Nullable<ParseOptions>): LanguageProcessor<AsmType, ContextType>;
    usedAutomatonFor(goalRuleName: string): Automaton;
    scan(sentence: string, options?: Nullable<ScanOptions>): ScanResult;
    parse(sentence: string, options?: Nullable<ParseOptions>): ParseResult;
    syntaxAnalysis(sppt: SharedPackedParseTree, options?: Nullable<ProcessOptions<AsmType, ContextType>>): SyntaxAnalysisResult<AsmType>;
    semanticAnalysis(asm: AsmType, options?: Nullable<ProcessOptions<AsmType, ContextType>>): SemanticAnalysisResult;
    process(sentence: string, options?: Nullable<ProcessOptions<AsmType, ContextType>>): ProcessResult<AsmType>;
    format(sentence: string, options?: Nullable<ProcessOptions<AsmType, ContextType>>): FormatResult;
    formatAsm(asm: AsmType, options?: Nullable<ProcessOptions<AsmType, ContextType>>): FormatResult;
    expectedTerminalsAt(sentence: string, position: number, options?: Nullable<ProcessOptions<AsmType, ContextType>>): ExpectedAtResult;
    expectedItemsAt(sentence: string, position: number, options?: Nullable<ProcessOptions<AsmType, ContextType>>): ExpectedAtResult;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.LanguageProcessor": unique symbol;
    };
}
export declare interface LanguageProcessorConfiguration<AsmType extends any, ContextType extends any> {
    readonly targetGrammarName: Nullable<SimpleName>;
    readonly defaultGoalRuleName: Nullable<GrammarRuleName>;
    readonly regexEngineKind: RegexEngineKind;
    readonly scannerKind: ScannerKind;
    readonly grammarString: Nullable<GrammarString>;
    readonly typesString: Nullable<TypesString>;
    readonly asmTransformString: Nullable<AsmTransformString>;
    readonly crossReferenceString: Nullable<CrossReferenceString>;
    readonly styleString: Nullable<StyleString>;
    readonly formatString: Nullable<FormatString>;
    readonly scannerResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<Scanner>>;
    readonly parserResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<Parser>>;
    readonly typesResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>>;
    readonly transformResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AsmTransformDomain>>;
    readonly crossReferenceResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<CrossReferenceDomain>>;
    readonly syntaxAnalyserResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<SyntaxAnalyser<AsmType>>>;
    readonly semanticAnalyserResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<SemanticAnalyser<AsmType, ContextType>>>;
    readonly styleResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AglStyleDomain>>;
    readonly formatResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<AglFormatDomain>>;
    readonly completionProviderResolver: Nullable<(p0: LanguageProcessor<AsmType, ContextType>) => ProcessResult<CompletionProvider<AsmType, ContextType>>>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.LanguageProcessorConfiguration": unique symbol;
    };
}
export declare abstract class ParserKind {
    private constructor();
    static get GLC(): ParserKind & {
        get name(): "GLC";
        get ordinal(): 0;
    };
    get name(): "GLC";
    get ordinal(): 0;
    static values(): Array<ParserKind>;
    static valueOf(value: string): ParserKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParserKind.$metadata$ {
    const constructor: abstract new () => ParserKind;
}
export declare interface LanguageObject<AsmType extends any, ContextType extends any> {
    readonly identity: LanguageIdentity;
    readonly qualifiedName: QualifiedName;
    readonly extends: KtList<LanguageObject<any, ContextType>>;
    readonly grammarString: string;
    readonly typesString: string;
    readonly kompositeString: string;
    readonly asmTransformString: string;
    readonly crossReferenceString: string;
    readonly styleString: string;
    readonly formatString: string;
    readonly grammarDomain: GrammarDomain;
    readonly typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    readonly kompositeDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    readonly asmTransformDomain: AsmTransformDomain;
    readonly crossReferenceDomain: CrossReferenceDomain;
    readonly styleDomain: AglStyleDomain;
    readonly formatDomain: AglFormatDomain;
    readonly defaultTargetGrammar: Grammar;
    readonly defaultTargetGoalRule: string;
    readonly syntaxAnalyser: Nullable<SyntaxAnalyser<AsmType>>;
    readonly semanticAnalyser: Nullable<SemanticAnalyser<AsmType, ContextType>>;
    readonly completionProvider: Nullable<CompletionProvider<AsmType, ContextType>>;
    readonly allGrammarString: string;
    readonly allTypesString: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.LanguageObject": unique symbol;
    };
}
export declare abstract class LanguageObjectAbstract<AsmType extends any, ContextType extends any> implements LanguageObject<AsmType, ContextType> {
    constructor();
    get qualifiedName(): QualifiedName;
    get kompositeDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get ruleSets(): KtMap<string, RuleSet>;
    get targetRuleSet(): RuleSet;
    get mapToGrammar(): (p0: number, p1: number) => RuleItem;
    get automata(): KtMap<string, Automaton>;
    get syntaxAnalyser(): Nullable<SyntaxAnalyser<AsmType>>;
    get semanticAnalyser(): Nullable<SemanticAnalyser<AsmType, ContextType>>;
    get allGrammarString(): string;
    get allTypesString(): string;
    abstract get identity(): LanguageIdentity;
    abstract get extends(): KtList<LanguageObject<any, ContextType>>;
    abstract get grammarString(): string;
    abstract get typesString(): string;
    abstract get kompositeString(): string;
    abstract get asmTransformString(): string;
    abstract get crossReferenceString(): string;
    abstract get styleString(): string;
    abstract get formatString(): string;
    abstract get grammarDomain(): GrammarDomain;
    abstract get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    abstract get asmTransformDomain(): AsmTransformDomain;
    abstract get crossReferenceDomain(): CrossReferenceDomain;
    abstract get styleDomain(): AglStyleDomain;
    abstract get formatDomain(): AglFormatDomain;
    abstract get defaultTargetGrammar(): Grammar;
    abstract get defaultTargetGoalRule(): string;
    abstract get completionProvider(): Nullable<CompletionProvider<AsmType, ContextType>>;
    readonly __doNotUseOrImplementIt: LanguageObject<AsmType, ContextType>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LanguageObjectAbstract.$metadata$ {
    const constructor: abstract new <AsmType extends any, ContextType extends any>() => LanguageObjectAbstract<AsmType, ContextType>;
}
export declare namespace LanguageObjectAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get GOAL_RULE(): number;
            get OP_NONE(): OptionNum;
            get SR(): number;
            get ER(): number;
            get WIDTH(): ParseAction;
            get HEIGHT(): ParseAction;
            get GRAFT(): ParseAction;
            get GOAL(): ParseAction;
            private constructor();
        }
    }
}
export declare interface SyntaxAnalysisOptions<AsmType extends any> {
    enabled: boolean;
    clone(): SyntaxAnalysisOptions<AsmType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.SyntaxAnalysisOptions": unique symbol;
    };
}
export declare interface SemanticAnalysisOptions<ContextType extends any> {
    enabled: boolean;
    locationMap: LocationMap;
    sentenceContext: Nullable<ContextType>;
    buildScope: boolean;
    replaceIfItemAlreadyExistsInScope: boolean;
    ifItemAlreadyExistsInScopeIssueKind: Nullable<LanguageIssueKind>;
    checkReferences: boolean;
    resolveReferences: boolean;
    readonly other: KtMap<string, any>;
    clone(): SemanticAnalysisOptions<ContextType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.SemanticAnalysisOptions": unique symbol;
    };
}
export declare interface CompletionProviderOptions<ContextType extends any> {
    sentenceContext: Nullable<ContextType>;
    depth: number;
    path: KtList<any/* Pair<number, number> */>;
    showOptionalItems: boolean;
    provideValuesForPatternTerminals: boolean;
    readonly other: KtMap<string, any>;
    clone(): CompletionProviderOptions<ContextType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.CompletionProviderOptions": unique symbol;
    };
}
export declare interface FormatOptions<SelfType extends any> {
    locationMap: Nullable<LocationMap>;
    readonly environment: KtMap<string, SelfType>;
    clone(): FormatOptions<SelfType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.FormatOptions": unique symbol;
    };
}
export declare interface ProcessOptions<AsmType extends any, ContextType extends any> {
    readonly scan: ScanOptions;
    readonly parse: ParseOptions;
    readonly syntaxAnalysis: SyntaxAnalysisOptions<AsmType>;
    readonly semanticAnalysis: SemanticAnalysisOptions<ContextType>;
    readonly completionProvider: CompletionProviderOptions<ContextType>;
    readonly format: FormatOptions<AsmType>;
    clone(): ProcessOptions<AsmType, ContextType>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.ProcessOptions": unique symbol;
    };
}
export declare interface SyntaxAnalysisResult<AsmType extends any> {
    readonly asm: Nullable<AsmType>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly locationMap: LocationMap;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.SyntaxAnalysisResult": unique symbol;
    };
}
export declare class ResolvedReference {
    constructor(source: Nullable<any>, sourceLocation: Nullable<InputLocation>, target: Nullable<any>, targetLocation: Nullable<InputLocation>);
    get source(): Nullable<any>;
    get sourceLocation(): Nullable<InputLocation>;
    get target(): Nullable<any>;
    get targetLocation(): Nullable<InputLocation>;
    copy(source?: Nullable<any>, sourceLocation?: Nullable<InputLocation>, target?: Nullable<any>, targetLocation?: Nullable<InputLocation>): ResolvedReference;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ResolvedReference.$metadata$ {
    const constructor: abstract new () => ResolvedReference;
}
export declare interface SemanticAnalysisResult {
    readonly resolvedReferences: KtList<ResolvedReference>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.SemanticAnalysisResult": unique symbol;
    };
}
export declare interface ProcessResult<AsmType extends any> {
    readonly asm: Nullable<AsmType>;
    readonly parse: Nullable<ParseResult>;
    readonly syntaxAnalysis: Nullable<SyntaxAnalysisResult<AsmType>>;
    readonly semanticAnalysis: Nullable<SemanticAnalysisResult>;
    readonly processIssues: IssueCollection<LanguageIssue>;
    readonly allIssues: IssueCollection<LanguageIssue>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.ProcessResult": unique symbol;
    };
}
export declare interface FormatResult {
    readonly output: KtMap<string, string>;
    readonly sentence: Nullable<string>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.FormatResult": unique symbol;
    };
}
export declare interface ExpectedAtResult {
    readonly requestedPosition: number;
    readonly offeredPosition: number;
    readonly isTerminalCompletion: boolean;
    readonly offset: number;
    readonly items: KtList<CompletionItem>;
    readonly issues: IssueCollection<LanguageIssue>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.processor.ExpectedAtResult": unique symbol;
    };
}
export declare interface SemanticAnalyser<AsmType extends any, ContextType extends any> {
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: AsmType, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<ContextType>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.semanticAnalyser.SemanticAnalyser": unique symbol;
    };
}
export declare interface CreateScopedItem {
    invoke(qualifiedName: KtList<string>, item: any, location: Nullable<InputLocation>): any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.semanticAnalyser.CreateScopedItem": unique symbol;
    };
}
export declare interface ResolveScopedItem {
    invoke(itemInScope: any): Nullable<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.semanticAnalyser.ResolveScopedItem": unique symbol;
    };
}
export declare interface SentenceContext {
    readonly resolveScopedItem: ResolveScopedItem;
    readonly createScopedItem: CreateScopedItem;
    readonly scopeForSentence: KtMap<any, ScopeSimple>;
    newScopeForSentence(sentenceIdentity: Nullable<any>): Scope;
    getScopeForSentenceOrNull(sentenceIdentity: Nullable<any>): Nullable<Scope>;
    getOrCreateScopeForSentence(sentenceIdentity: Nullable<any>): Scope;
    findItemsByQualifiedNameConformingTo(qname: KtList<string>, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsNamedConformingTo(name: string, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsConformingTo(conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    addToScope(sentenceIdentity: Nullable<any>, qualifiedName: KtList<string>, itemTypeName: QualifiedName, location: Nullable<InputLocation>, item: any): void;
    union(other: SentenceContext): SentenceContext;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.api.semanticAnalyser.SentenceContext": unique symbol;
    };
}
export declare interface AsmPath {
    readonly value: string;
    readonly segments: KtList<string>;
    readonly parent: Nullable<AsmPath>;
    plus(segment: string): AsmPath;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmPath": unique symbol;
    };
}
export declare interface Asm {
    readonly root: KtList<AsmValue>;
    readonly elementIndex: KtMap<AsmPath, AsmStructure>;
    addToIndex(value: AsmStructure): void;
    traverseDepthFirst(callback: AsmTreeWalker): void;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.Asm": unique symbol;
    };
}
export declare interface AsmValue {
    readonly qualifiedTypeName: QualifiedName;
    readonly typeName: SimpleName;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmValue": unique symbol;
    };
}
export declare interface AsmNothing extends AsmValue {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmNothing": unique symbol;
    } & AsmValue["__doNotUseOrImplementIt"];
}
export declare interface AsmAny extends AsmValue {
    readonly value: any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmAny": unique symbol;
    } & AsmValue["__doNotUseOrImplementIt"];
}
export declare interface AsmPrimitive extends AsmValue {
    readonly value: any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmPrimitive": unique symbol;
    } & AsmValue["__doNotUseOrImplementIt"];
}
export declare interface AsmReference {
    readonly reference: string;
    readonly value: Nullable<AsmStructure>;
    resolveAs(value: Nullable<AsmStructure>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmReference": unique symbol;
    };
}
export declare class PropertyValueName implements PublicValueType {
    constructor(value: string);
    get value(): string;
    toString(): string;
    copy(value?: string): PropertyValueName;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyValueName.$metadata$ {
    const constructor: abstract new () => PropertyValueName;
}
export declare interface AsmStructure extends AsmValue {
    readonly parsePath: string;
    syntaxAnalyserPath: Nullable<AsmPath>;
    readonly semanticQualifiedPath: Nullable<KtList<string>>;
    readonly property: KtMap<PropertyValueName, AsmStructureProperty>;
    readonly propertyOrdered: KtList<AsmStructureProperty>;
    readonly children: KtList<AsmValue>;
    setSemanticQualifiedPath(segments: KtList<string>): void;
    qualifiedName(separator: string): Nullable<string>;
    hasProperty(name: PropertyValueName): boolean;
    getProperty(name: PropertyValueName): AsmValue;
    getPropertyOrNothing(name: PropertyValueName): AsmValue;
    getPropertyOrNull(name: PropertyValueName): Nullable<AsmValue>;
    setProperty(name: PropertyValueName, value: AsmValue, childIndex: number): void;
    getPropertyAsAsmPrimitiveOrNull(name: string): Nullable<AsmPrimitive>;
    getPropertyAsStringOrNull(name: string): Nullable<string>;
    getPropertyAsAsmStructureOrNull(name: string): Nullable<AsmStructure>;
    getPropertyAsAsmListOrNull(name: string): Nullable<AsmList>;
    getPropertyAsListOfAsmPrimitiveOrNull(name: string): Nullable<KtList<AsmPrimitive>>;
    getPropertyAsListOfAnyOrNull(name: string): Nullable<KtList<any>>;
    getPropertyAsListOfStringOrNull(name: string): Nullable<KtList<string>>;
    getPropertyAsListOfAsmStructureOrNull(name: string): Nullable<KtList<AsmStructure>>;
    getPropertyAsAsmListSeparatedOrNull(name: string): Nullable<AsmListSeparated>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmStructure": unique symbol;
    } & AsmValue["__doNotUseOrImplementIt"];
}
export declare interface AsmStructureProperty {
    readonly name: PropertyValueName;
    readonly value: AsmValue;
    readonly index: number;
    readonly isReference: boolean;
    convertToReferenceTo(referredValue: Nullable<AsmStructure>): void;
    equalTo(other: AsmStructureProperty): boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmStructureProperty": unique symbol;
    };
}
export declare interface AsmCollection extends AsmValue {
    readonly elements: any/* Collection<AsmValue> */;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmCollection": unique symbol;
    } & AsmValue["__doNotUseOrImplementIt"];
}
export declare interface AsmSet extends AsmCollection {
    readonly elements: KtSet<AsmValue>;
    readonly isEmpty: boolean;
    readonly isNotEmpty: boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmSet": unique symbol;
    } & AsmCollection["__doNotUseOrImplementIt"];
}
export declare interface AsmList extends AsmCollection {
    readonly elements: KtList<AsmValue>;
    readonly isEmpty: boolean;
    readonly isNotEmpty: boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmList": unique symbol;
    } & AsmCollection["__doNotUseOrImplementIt"];
}
export declare interface AsmListSeparated extends AsmList {
    readonly elements: KtList<AsmValue>/* ListSeparated<AsmValue, AsmValue, AsmValue> */;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmListSeparated": unique symbol;
    } & AsmList["__doNotUseOrImplementIt"];
}
export declare interface AsmLambda extends AsmValue {
    invoke(args: KtMap<string, AsmValue>): AsmValue;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmLambda": unique symbol;
    } & AsmValue["__doNotUseOrImplementIt"];
}
export declare interface AsmTreeWalker {
    beforeRoot(root: AsmValue): void;
    afterRoot(root: AsmValue): void;
    onNothing(owningProperty: Nullable<AsmStructureProperty>, value: AsmNothing): void;
    onPrimitive(owningProperty: Nullable<AsmStructureProperty>, value: AsmPrimitive): void;
    beforeStructure(owningProperty: Nullable<AsmStructureProperty>, value: AsmStructure): void;
    onProperty(owner: AsmStructure, property: AsmStructureProperty): void;
    afterStructure(owningProperty: Nullable<AsmStructureProperty>, value: AsmStructure): void;
    beforeList(owningProperty: Nullable<AsmStructureProperty>, value: AsmList): void;
    afterList(owningProperty: Nullable<AsmStructureProperty>, value: AsmList): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asm.api.AsmTreeWalker": unique symbol;
    };
}
export declare abstract class AglAsm {
    static readonly getInstance: () => typeof AglAsm.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglAsm.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get komposite(): string;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        private constructor();
    }
}
export declare class AsmPathSimple implements AsmPath {
    constructor(value: string);
    get value(): string;
    get segments(): KtList<string>;
    get parent(): Nullable<AsmPath>;
    plus(segment: string): AsmPathSimple;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmPath["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmPathSimple.$metadata$ {
    const constructor: abstract new () => AsmPathSimple;
}
export declare namespace AsmPathSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get SEPARATOR(): string;
            get ROOT(): AsmPathSimple;
            private constructor();
        }
    }
}
export declare class AsmSimple implements Asm {
    constructor(objectGraph: ObjectGraphAccessorMutatorAsmSimple);
    get objectGraph(): ObjectGraphAccessorMutatorAsmSimple;
    get root(): KtList<AsmValue>;
    get elementIndex(): KtMutableMap<AsmPath, AsmStructure>;
    addRoot(root: AsmValue): boolean;
    removeRoot(root: any): boolean;
    createStructure(parsePath: string, typeName: QualifiedName): AsmStructureSimple;
    addToIndex(value: AsmStructure): void;
    traverseDepthFirst(walker: AsmTreeWalker): void;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: Asm["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmSimple.$metadata$ {
    const constructor: abstract new () => AsmSimple;
}
export declare namespace AsmSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            traverseDepthFirst(roots: KtList<AsmValue>, walker: AsmTreeWalker): void;
            private constructor();
        }
    }
}
export declare abstract class AsmValueAbstract implements AsmValue {
    constructor();
    get typeName(): SimpleName;
    abstract get qualifiedTypeName(): QualifiedName;
    asString(indent?: Indent): string;
    abstract equalTo(other: AsmValue): boolean;
    readonly __doNotUseOrImplementIt: AsmValue["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmValueAbstract.$metadata$ {
    const constructor: abstract new () => AsmValueAbstract;
}
export declare abstract class AsmNothingSimple {
    static readonly getInstance: () => typeof AsmNothingSimple.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmNothingSimple.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends AsmValueAbstract.$metadata$.constructor implements AsmNothing {
        get qualifiedTypeName(): QualifiedName;
        asString(indent?: Indent): string;
        equalTo(other: AsmValue): boolean;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
        toString(): string;
        readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmNothing["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare class AsmAnySimple extends AsmValueAbstract.$metadata$.constructor implements AsmAny {
    constructor(value: any);
    get value(): any;
    get qualifiedTypeName(): QualifiedName;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmAny["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmAnySimple.$metadata$ {
    const constructor: abstract new () => AsmAnySimple;
}
export declare namespace AsmAnySimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            stdAny(value: any): AsmAnySimple;
            private constructor();
        }
    }
}
export declare class AsmPrimitiveSimple extends AsmValueAbstract.$metadata$.constructor implements AsmPrimitive {
    constructor(qualifiedTypeName: QualifiedName, value: any);
    get qualifiedTypeName(): QualifiedName;
    get value(): any;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmPrimitive["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmPrimitiveSimple.$metadata$ {
    const constructor: abstract new () => AsmPrimitiveSimple;
}
export declare namespace AsmPrimitiveSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            stdString(value: string): AsmPrimitiveSimple;
            stdBoolean(value: boolean): AsmPrimitiveSimple;
            stdInteger(value: bigint): AsmPrimitiveSimple;
            stdReal(value: number): AsmPrimitiveSimple;
            private constructor();
        }
    }
}
export declare class AsmReferenceSimple extends AsmValueAbstract.$metadata$.constructor implements AsmReference {
    constructor(reference: string, value: Nullable<AsmStructure>);
    get reference(): string;
    get value(): Nullable<AsmStructure>;
    set value(value: Nullable<AsmStructure>);
    get qualifiedTypeName(): QualifiedName;
    resolveAs(value: Nullable<AsmStructure>): void;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmReferenceSimple.$metadata$ {
    const constructor: abstract new () => AsmReferenceSimple;
}
export declare class AsmStructureSimple extends AsmValueAbstract.$metadata$.constructor implements AsmStructure {
    constructor(qualifiedTypeName: QualifiedName);
    get qualifiedTypeName(): QualifiedName;
    get parsePath(): string;
    set parsePath(value: string);
    get syntaxAnalyserPath(): Nullable<AsmPath>;
    set syntaxAnalyserPath(value: Nullable<AsmPath>);
    get semanticQualifiedPath(): Nullable<KtList<string>>;
    set semanticQualifiedPath(value: Nullable<KtList<string>>);
    get property(): KtMap<PropertyValueName, AsmStructureProperty>;
    get propertyOrdered(): KtList<AsmStructureProperty>;
    get children(): KtList<AsmStructureSimple>;
    qualifiedName(separator: string): Nullable<string>;
    setSemanticQualifiedPath(segments: KtList<string>): void;
    hasProperty(name: PropertyValueName): boolean;
    getPropertyAsReferenceOrNull(name: PropertyValueName): Nullable<AsmReferenceSimple>;
    getPropertyAsListOrNull(name: PropertyValueName): Nullable<KtList<any>>;
    getProperty(name: PropertyValueName): AsmValue;
    getPropertyOrNothing(name: PropertyValueName): AsmValue;
    getPropertyOrNull(name: PropertyValueName): Nullable<AsmValue>;
    getPropertyAsReference(name: PropertyValueName): AsmReferenceSimple;
    getPropertyAsList(name: PropertyValueName): KtList<any>;
    getPropertyAsListOfElement(name: PropertyValueName): KtList<AsmStructureSimple>;
    setProperty(name: PropertyValueName, value: AsmValue, childIndex: number): void;
    addAllProperty(value: KtList<AsmStructurePropertySimple>): void;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    getPropertyAsAsmPrimitiveOrNull(name: string): Nullable<AsmPrimitive>;
    getPropertyAsStringOrNull(name: string): Nullable<string>;
    getPropertyAsAsmStructureOrNull(name: string): Nullable<AsmStructure>;
    getPropertyAsAsmListOrNull(name: string): Nullable<AsmList>;
    getPropertyAsListOfAsmPrimitiveOrNull(name: string): Nullable<KtList<AsmPrimitive>>;
    getPropertyAsListOfAnyOrNull(name: string): Nullable<KtList<any>>;
    getPropertyAsListOfStringOrNull(name: string): Nullable<KtList<string>>;
    getPropertyAsListOfAsmStructureOrNull(name: string): Nullable<KtList<AsmStructure>>;
    getPropertyAsAsmListSeparatedOrNull(name: string): Nullable<AsmListSeparated>;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmStructure["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmStructureSimple.$metadata$ {
    const constructor: abstract new () => AsmStructureSimple;
}
export declare class AsmStructurePropertySimple implements AsmStructureProperty {
    constructor(name: PropertyValueName, index: number, value: AsmValue);
    get name(): PropertyValueName;
    get index(): number;
    get value(): AsmValue;
    set value(value: AsmValue);
    get isReference(): boolean;
    convertToReferenceTo(referredValue: Nullable<AsmStructure>): void;
    equalTo(other: AsmStructureProperty): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmStructureProperty["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmStructurePropertySimple.$metadata$ {
    const constructor: abstract new () => AsmStructurePropertySimple;
}
export declare namespace AsmStructurePropertySimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get TO_STRING_MAX_LEN(): number;
            private constructor();
        }
    }
}
export declare class AsmSetSimple extends AsmValueAbstract.$metadata$.constructor implements AsmSet {
    constructor(elements: KtSet<AsmValue>);
    get elements(): KtSet<AsmValue>;
    get qualifiedTypeName(): QualifiedName;
    get isEmpty(): boolean;
    get isNotEmpty(): boolean;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmSet["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmSetSimple.$metadata$ {
    const constructor: abstract new () => AsmSetSimple;
}
export declare class AsmListSimple extends AsmValueAbstract.$metadata$.constructor implements AsmList {
    constructor(elements: KtList<AsmValue>);
    get elements(): KtList<AsmValue>;
    get qualifiedTypeName(): QualifiedName;
    get isEmpty(): boolean;
    get isNotEmpty(): boolean;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmList["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmListSimple.$metadata$ {
    const constructor: abstract new () => AsmListSimple;
}
export declare class AsmListSeparatedSimple extends AsmValueAbstract.$metadata$.constructor implements AsmListSeparated {
    constructor(elements: KtList<AsmValue>/* ListSeparated<AsmValue, AsmValue, AsmValue> */);
    get elements(): KtList<AsmValue>/* ListSeparated<AsmValue, AsmValue, AsmValue> */;
    get qualifiedTypeName(): QualifiedName;
    get isEmpty(): boolean;
    get isNotEmpty(): boolean;
    asString(indent?: Indent): string;
    equalTo(other: AsmValue): boolean;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmListSeparated["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmListSeparatedSimple.$metadata$ {
    const constructor: abstract new () => AsmListSeparatedSimple;
}
export declare class AsmLambdaSimple extends AsmValueAbstract.$metadata$.constructor implements AsmLambda {
    constructor(lambda: (p0: AsmValue) => AsmValue);
    get lambda(): (p0: AsmValue) => AsmValue;
    get qualifiedTypeName(): QualifiedName;
    invoke(args: KtMap<string, AsmValue>): AsmValue;
    equalTo(other: AsmValue): boolean;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: AsmValueAbstract["__doNotUseOrImplementIt"] & AsmLambda["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmLambdaSimple.$metadata$ {
    const constructor: abstract new () => AsmLambdaSimple;
}
export declare function asmSimple(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */ | undefined, defaultNamespace: QualifiedName | undefined, crossReferenceDomain: CrossReferenceDomain | undefined, sentenceId: Nullable<any> | undefined, sentenceContext: Nullable<SentenceContext> | undefined, resolveReferences: boolean | undefined, failIfIssues: boolean | undefined, resolvedReferences: KtMutableList<ResolvedReference> | undefined, init: (p0: AsmSimpleBuilder) => void): Asm;
export declare class AsmSimpleBuilder {
    constructor(_typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, _defaultNamespace: TypesNamespace, _crossReferenceDomain: CrossReferenceDomain, _sentenceId: Nullable<any>, _context: Nullable<SentenceContext>, resolveReferences: boolean, failIfIssues: boolean, resolvedReferences: KtMutableList<ResolvedReference>);
    string(value: string): void;
    element(typeName: string, init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    tuple(init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    listOfString(items: Array<string>): AsmList;
    list(init: (p0: ListAsmElementSimpleBuilder) => void): AsmList;
    build(): AsmSimple;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmSimpleBuilder.$metadata$ {
    const constructor: abstract new () => AsmSimpleBuilder;
}
export declare class AsmElementSimpleBuilder {
    constructor(_typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, _defaultNamespace: TypesNamespace, _crossReferenceDomain: CrossReferenceDomain, _context: Nullable<SentenceContext>, _scopeMap: KtMutableMap<AsmPath, ScopeSimple>, _asm: AsmSimple, _identifyingValueInFor: (p0: SimpleName, p1: AsmStructure) => Nullable<any>, _asmPath: AsmPath, _typeName: string, _isRoot: boolean, _parentScope: Nullable<ScopeSimple>);
    propertyUnnamedString(value: Nullable<string>): void;
    propertyString(name: string, value: Nullable<string>): void;
    propertyNothing(name: string): void;
    propertyUnnamedElement(typeName: string, init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    propertyTuple(name: string, tupleTypeId: Nullable<number> | undefined, init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    propertyElement(name: string, init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    propertyElementExplicitType(name: string, typeName: string, init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    propertyUnnamedListOfString(list: KtList<string>): void;
    propertyListOfString(name: string, list: KtList<string>): void;
    propertyUnnamedListOfElement(init: (p0: ListAsmElementSimpleBuilder) => void): AsmList;
    propertyListOfElement(name: string, init: (p0: ListAsmElementSimpleBuilder) => void): AsmList;
    reference(name: string, elementReference: string): void;
    build(): AsmStructure;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmElementSimpleBuilder.$metadata$ {
    const constructor: abstract new () => AsmElementSimpleBuilder;
}
export declare class ListAsmElementSimpleBuilder {
    constructor(_typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, _defaultNamespace: TypesNamespace, _crossReferenceDomain: CrossReferenceDomain, _context: Nullable<SentenceContext>, _scopeMap: KtMutableMap<AsmPath, ScopeSimple>, _asm: AsmSimple, _asmPath: AsmPath, _parentScope: Nullable<ScopeSimple>, _identifyingValueInFor: (p0: SimpleName, p1: AsmStructure) => Nullable<any>);
    string(value: string): void;
    list(init: (p0: ListAsmElementSimpleBuilder) => void): void;
    element(typeName: string, init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    tuple(init: (p0: AsmElementSimpleBuilder) => void): AsmStructure;
    build(): AsmList;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ListAsmElementSimpleBuilder.$metadata$ {
    const constructor: abstract new () => ListAsmElementSimpleBuilder;
}
export declare interface AsmTransformDomain extends Domain<AsmTransformNamespace, AsmTransformRuleSet> {
    readonly typesDomain: Nullable<Domain<TypesNamespace, TypeDefinition>>/* Nullable<TypesDomain> */;
    readonly namespace: KtList<AsmTransformNamespace>;
    findOrCreateNamespace(qualifiedName: QualifiedName, imports: KtList<Import>): AsmTransformNamespace;
    findTypeForGrammarRule(grammarQualifiedName: QualifiedName, ruleName: GrammarRuleName): Nullable<TypeInstance>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.AsmTransformDomain": unique symbol;
    } & Domain<AsmTransformNamespace, AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface AsmTransformNamespace extends Namespace<AsmTransformRuleSet> {
    createOwnedTransformRuleSet(name: SimpleName, _extends: KtList<AsmTransformRuleSetReference>, options: OptionHolder): AsmTransformRuleSet;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.AsmTransformNamespace": unique symbol;
    } & Namespace<AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface AsmTransformRuleSetReference extends DefinitionReference<AsmTransformRuleSet> {
    cloneTo(ns: AsmTransformNamespace): AsmTransformRuleSetReference;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.AsmTransformRuleSetReference": unique symbol;
    } & DefinitionReference<AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface AsmTransformRuleSet extends Definition<AsmTransformRuleSet> {
    readonly namespace: AsmTransformNamespace;
    readonly extends: KtList<AsmTransformRuleSetReference>;
    readonly importTypes: KtList<Import>;
    readonly rules: KtMap<GrammarRuleName, AsmTransformationRule>;
    readonly createObjectRules: KtList<CreateObjectRule>;
    readonly modifyObjectRules: KtList<ModifyObjectRule>;
    findOwnedTrRuleForGrammarRuleNamedOrNull(grmRuleName: GrammarRuleName): Nullable<AsmTransformationRule>;
    findAllTrRuleForGrammarRuleNamedOrNull(grmRuleName: GrammarRuleName): Nullable<AsmTransformationRule>;
    addImportType(value: Import): void;
    setRule(rule: AsmTransformationRule): void;
    cloneTo(ns: AsmTransformNamespace): AsmTransformRuleSet;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.AsmTransformRuleSet": unique symbol;
    } & Definition<AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface AsmTransformationRule {
    grammarRuleName: GrammarRuleName;
    readonly expression: Expression;
    readonly isResolved: boolean;
    readonly resolvedType: TypeInstance;
    resolveTypeAs(type: TypeInstance): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.AsmTransformationRule": unique symbol;
    };
}
export declare interface CreateObjectRule extends AsmTransformationRule {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.CreateObjectRule": unique symbol;
    } & AsmTransformationRule["__doNotUseOrImplementIt"];
}
export declare interface SelfStatement {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.SelfStatement": unique symbol;
    };
}
export declare interface ModifyObjectRule extends AsmTransformationRule {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.asmTransform.api.ModifyObjectRule": unique symbol;
    } & AsmTransformationRule["__doNotUseOrImplementIt"];
}
export declare class AsmTransformDomainDefault extends DomainAbstract.$metadata$.constructor<AsmTransformNamespace, AsmTransformRuleSet> implements AsmTransformDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespace?: KtList<AsmTransformNamespace>);
    get name(): SimpleName;
    get typesDomain(): Nullable<Domain<TypesNamespace, TypeDefinition>>/* Nullable<TypesDomain> */;
    set typesDomain(value: Nullable<Domain<TypesNamespace, TypeDefinition>>/* Nullable<TypesDomain> */);
    findOrCreateNamespace(qualifiedName: QualifiedName, imports: KtList<Import>): AsmTransformNamespace;
    findTypeForGrammarRule(grammarQualifiedName: QualifiedName, ruleName: GrammarRuleName): Nullable<TypeInstance>;
    get namespace(): KtList<AsmTransformNamespace>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: AsmTransformDomain["__doNotUseOrImplementIt"] & DomainAbstract<AsmTransformNamespace, AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformDomainDefault.$metadata$ {
    const constructor: abstract new () => AsmTransformDomainDefault;
}
export declare namespace AsmTransformDomainDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            fromString(context: SentenceContext, transformStr: AsmTransformString): ProcessResult<AsmTransformDomain>;
            fromGrammarDomain(grammarDomain: GrammarDomain, typesDomain?: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, configuration?: Nullable<Grammar2TypesDomainMapping>): ProcessResult<AsmTransformDomain>;
            private constructor();
        }
    }
}
export declare class AsmTransformNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<AsmTransformRuleSet> implements AsmTransformNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    createOwnedTransformRuleSet(name: SimpleName, _extends: KtList<AsmTransformRuleSetReference>, options: OptionHolder): AsmTransformRuleSet;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: AsmTransformNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformNamespaceDefault.$metadata$ {
    const constructor: abstract new () => AsmTransformNamespaceDefault;
}
export declare class AsmTransformRuleSetReferenceDefault implements AsmTransformRuleSetReference {
    constructor(localNamespace: AsmTransformNamespace, nameOrQName: PossiblyQualifiedName);
    get localNamespace(): AsmTransformNamespace;
    get nameOrQName(): PossiblyQualifiedName;
    get resolved(): Nullable<AsmTransformRuleSet>;
    set resolved(value: Nullable<AsmTransformRuleSet>);
    resolveAs(resolved: AsmTransformRuleSet): void;
    cloneTo(ns: AsmTransformNamespace): AsmTransformRuleSetReference;
    copy(localNamespace?: AsmTransformNamespace, nameOrQName?: PossiblyQualifiedName): AsmTransformRuleSetReferenceDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: AsmTransformRuleSetReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformRuleSetReferenceDefault.$metadata$ {
    const constructor: abstract new () => AsmTransformRuleSetReferenceDefault;
}
export declare class AsmTransformRuleSetDefault extends DefinitionAbstract.$metadata$.constructor<AsmTransformRuleSet> implements AsmTransformRuleSet {
    constructor(namespace: AsmTransformNamespace, name: SimpleName, argExtends: KtList<AsmTransformRuleSetReference> | undefined, options: OptionHolder | undefined, _rules: KtList<AsmTransformationRule>);
    get namespace(): AsmTransformNamespace;
    get name(): SimpleName;
    get options(): OptionHolder;
    get extends(): KtList<AsmTransformRuleSetReference>;
    get importTypes(): KtList<Import>;
    get rules(): KtMap<GrammarRuleName, AsmTransformationRule>;
    get createObjectRules(): KtList<CreateObjectRule>;
    get modifyObjectRules(): KtList<ModifyObjectRule>;
    addImportType(value: Import): void;
    findOwnedTrRuleForGrammarRuleNamedOrNull(grmRuleName: GrammarRuleName): Nullable<AsmTransformationRule>;
    findAllTrRuleForGrammarRuleNamedOrNull(grmRuleName: GrammarRuleName): Nullable<AsmTransformationRule>;
    cloneTo(ns: AsmTransformNamespace): AsmTransformRuleSet;
    addExtends(other: AsmTransformRuleSetReference): void;
    setRule(rule: AsmTransformationRule): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmTransformRuleSet["__doNotUseOrImplementIt"] & DefinitionAbstract<AsmTransformRuleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformRuleSetDefault.$metadata$ {
    const constructor: abstract new () => AsmTransformRuleSetDefault;
}
export declare class AsmTransformationRuleDefault implements AsmTransformationRule {
    constructor(expression: Expression);
    get expression(): Expression;
    get grammarRuleName(): GrammarRuleName;
    set grammarRuleName(value: GrammarRuleName);
    get isResolved(): boolean;
    get resolvedType(): TypeInstance;
    resolveTypeAs(type: TypeInstance): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: AsmTransformationRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformationRuleDefault.$metadata$ {
    const constructor: abstract new () => AsmTransformationRuleDefault;
}
export declare function asmTransform(name: string, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, createTypes: boolean, init: (p0: AsmTransformModelBuilder) => void): AsmTransformDomain;
export declare class AsmTransformModelBuilder {
    private constructor();
    namespace(qualifiedName: string, init: (p0: AsmTransformNamespaceBuilder) => void): void;
    build(): AsmTransformDomain;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformModelBuilder.$metadata$ {
    const constructor: abstract new () => AsmTransformModelBuilder;
}
export declare class AsmTransformNamespaceBuilder {
    private constructor();
    imports(imports: Array<string>): void;
    ruleSet(name: string, init: (p0: AsmTransformRuleSetBuilder) => void): void;
    build(): AsmTransformNamespace;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformNamespaceBuilder.$metadata$ {
    const constructor: abstract new () => AsmTransformNamespaceBuilder;
}
export declare class AsmTransformRuleSetBuilder {
    private constructor();
    expression(expressionStr: string): Expression;
    extends(list: Array<string>): void;
    importTypes(imports: Array<string>): void;
    leafStringRule(grammarRuleName: string): void;
    transRule(grammarRuleName: string, typeName: string, expressionStr: string): void;
    transToListOf(grammarRuleName: string, elementTypeName: string, expressionStr: string): void;
    child0StringRule(grammarRuleName: string): void;
    subtypeRule(grammarRuleName: string, typeName: string): void;
    unionRule(grammarRuleName: string, typeName: string, expressionStr: string, init: (p0: SubtypeListBuilder) => void): void;
    createObject(grammarRuleName: string, typeName: string, modifyStatements?: (p0: AssignmentBuilder) => void): void;
    build(): AsmTransformRuleSet;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformRuleSetBuilder.$metadata$ {
    const constructor: abstract new () => AsmTransformRuleSetBuilder;
}
export declare class AssignmentBuilder {
    constructor();
    assignment(lhsPropertyName: string, lhsGrammarRuleIndex: Nullable<number>, expressionStr: string): void;
    build(): KtList<VariableAssignmentStatement>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AssignmentBuilder.$metadata$ {
    const constructor: abstract new () => AssignmentBuilder;
}
export declare abstract class AsmTransform {
    static readonly getInstance: () => typeof AsmTransform.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransform.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<AsmTransformDomain, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get goalRuleName(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get formatDomain(): AglFormatDomain;
        get styleDomain(): AglStyleDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): SyntaxAnalyser<AsmTransformDomain>;
        get semanticAnalyser(): SemanticAnalyser<AsmTransformDomain, SentenceContext>;
        get completionProvider(): CompletionProvider<AsmTransformDomain, SentenceContext>;
        toString(): string;
        private constructor();
    }
}
export declare class AsmTransformCompletionProvider extends CompletionProviderAbstract.$metadata$.constructor<AsmTransformDomain, SentenceContext> {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformCompletionProvider.$metadata$ {
    const constructor: abstract new () => AsmTransformCompletionProvider;
}
export declare class AsmTransformInterpreter {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, objectGraph: ObjectGraphAccessorMutator);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get objectGraph(): ObjectGraphAccessorMutator;
    get issues(): IssueHolder;
    get exprInterpreter(): ExpressionsInterpreterOverTypedObject;
    clear(): void;
    evaluate(evc: EvaluationContext, trRule: AsmTransformationRule): TypedObject;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformInterpreter.$metadata$ {
    const constructor: abstract new () => AsmTransformInterpreter;
}
export declare namespace AsmTransformInterpreter {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get SELF(): string;
            get PATH(): PropertyName;
            get ALTERNATIVE(): PropertyName;
            get CHILD(): PropertyName;
            get CHILDREN(): PropertyName;
            get MATCHED_TEXT(): PropertyName;
            get LIST_OF_ANY(): TypeInstance;
            get SLIST_OF_ANY(): TypeInstance;
            get CMP_STR_MEM(): KtSet<PropertyCharacteristic>;
            get parseNodeTypesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
            get parseNodeNamespace(): TypesNamespace;
            get PARSE_NODE_TYPE_LEAF(): TypeDefinition;
            get PARSE_NODE_TYPE_BRANCH_SIMPLE(): TypeInstance;
            get PARSE_NODE_TYPE_BRANCH_SEPARATED(): TypeInstance;
            private constructor();
        }
    }
}
export declare class AsmTransformSemanticAnalyser implements SemanticAnalyser<AsmTransformDomain, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: AsmTransformDomain, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<AsmTransformDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => AsmTransformSemanticAnalyser;
}
export declare namespace AsmTransformSemanticAnalyser {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get OPTION_CREATE_TYPES(): string;
            get OPTION_OVERRIDE_DEFAULT(): string;
            private constructor();
        }
    }
}
export declare class AsmTransformSyntaxAnalyser extends SyntaxAnalyserByMethodRegistrationAbstract.$metadata$.constructor<AsmTransformDomain> {
    constructor();
    get extendsSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    get embeddedSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    registerHandlers(): void;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AsmTransformSyntaxAnalyser.$metadata$ {
    const constructor: abstract new () => AsmTransformSyntaxAnalyser;
}
export declare class OptionHolderDefault implements OptionHolder {
    constructor(parent?: Nullable<OptionHolder>, options?: KtMap<string, any>);
    get parent(): Nullable<OptionHolder>;
    set parent(value: Nullable<OptionHolder>);
    get options(): KtMap<string, any>;
    get<T>(name: string): Nullable<T>;
    clone(parent: Nullable<OptionHolder>): OptionHolder;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: OptionHolder["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OptionHolderDefault.$metadata$ {
    const constructor: abstract new () => OptionHolderDefault;
}
export declare abstract class DomainAbstract<NT extends Namespace<DT>, DT extends Definition<DT>> implements Domain<NT, DT> {
    constructor(namespace: KtList<NT>, options: OptionHolder);
    get options(): OptionHolder;
    get allDefinitions(): KtList<DT>;
    get isEmpty(): boolean;
    get namespace(): KtList<NT>;
    findNamespaceOrNull(qualifiedName: QualifiedName): Nullable<Namespace<DT>>;
    findFirstDefinitionByPossiblyQualifiedNameOrNull(pqn: PossiblyQualifiedName): Nullable<DT>;
    findDefinitionByQualifiedNameOrNull(qualifiedName: QualifiedName): Nullable<DT>;
    findFirstDefinitionByNameOrNull(simpleName: SimpleName): Nullable<DT>;
    resolveReference(reference: DefinitionReference<DT>): Nullable<DT>;
    connectionNamespaceOptionHolderParentsToThis(): void;
    addNamespace(value: NT): void;
    mergeNamespace(value: NT): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    abstract get name(): SimpleName;
    readonly __doNotUseOrImplementIt: Domain<NT, DT>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DomainAbstract.$metadata$ {
    const constructor: abstract new <NT extends Namespace<DT>, DT extends Definition<DT>>() => DomainAbstract<NT, DT>;
}
export declare abstract class NamespaceAbstract<DT extends Definition<DT>> implements Namespace<DT> {
    constructor(options: OptionHolder, argImport: KtList<Import>);
    get options(): OptionHolder;
    get definition(): KtList<DT>;
    get definitionByName(): KtMap<SimpleName, DT>;
    protected get _importedNamespaces(): KtMutableMap<QualifiedName, Nullable<Namespace<DT>>>;
    protected get _definition(): (KtMap<SimpleName, DT> & KtMutableMap<SimpleName, DT>)/* LinkedHashMap<SimpleName, DT> */;
    get import(): KtList<Import>;
    resolveImports(domain: Domain<Namespace<DT>, DT>): void;
    findDefinitionOrNull(simpleName: SimpleName): Nullable<DT>;
    findOwnedDefinitionOrNull(simpleName: SimpleName): Nullable<DT>;
    connectionDefinitionOptionHolderParentsToThis(): void;
    addImport(value: Import): void;
    addDefinition(value: DT): void;
    merge(value: Namespace<DT>): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    addAllDefinition(value: any/* Iterable<DT> */): void;
    abstract get qualifiedName(): QualifiedName;
    readonly __doNotUseOrImplementIt: Namespace<DT>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NamespaceAbstract.$metadata$ {
    const constructor: abstract new <DT extends Definition<DT>>() => NamespaceAbstract<DT>;
}
export declare abstract class DefinitionAbstract<DT extends Definition<DT>> implements Definition<DT> {
    constructor();
    get qualifiedName(): QualifiedName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    abstract get namespace(): Namespace<DT>;
    abstract get name(): SimpleName;
    abstract get options(): OptionHolder;
    readonly __doNotUseOrImplementIt: Definition<DT>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DefinitionAbstract.$metadata$ {
    const constructor: abstract new <DT extends Definition<DT>>() => DefinitionAbstract<DT>;
}
export declare class DomainDefault extends DomainAbstract.$metadata$.constructor<NamespaceDefault, DefinitionDefault> {
    constructor(name: SimpleName, options: OptionHolder, namespace?: KtList<NamespaceDefault>);
    get name(): SimpleName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DomainDefault.$metadata$ {
    const constructor: abstract new () => DomainDefault;
}
export declare class NamespaceDefault extends NamespaceAbstract.$metadata$.constructor<DefinitionDefault> {
    constructor(qualifiedName: QualifiedName, options: OptionHolder, _import: KtList<Import>);
    get qualifiedName(): QualifiedName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NamespaceDefault.$metadata$ {
    const constructor: abstract new () => NamespaceDefault;
}
export declare class DefinitionDefault extends DefinitionAbstract.$metadata$.constructor<DefinitionDefault> {
    constructor(namespace: Namespace<DefinitionDefault>, name: SimpleName, options?: OptionHolder);
    get namespace(): Namespace<DefinitionDefault>;
    get name(): SimpleName;
    get options(): OptionHolder;
    asString(indent?: Indent, imports?: KtList<Import>): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DefinitionDefault.$metadata$ {
    const constructor: abstract new () => DefinitionDefault;
}
export declare interface PossiblyQualifiedName {
    readonly value: string;
    readonly simpleName: SimpleName;
    asQualifiedName(namespace: Nullable<QualifiedName>): QualifiedName;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.PossiblyQualifiedName": unique symbol;
    };
}
export declare abstract class PossiblyQualifiedName {
    static readonly getInstance: () => typeof PossiblyQualifiedName.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PossiblyQualifiedName.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        private constructor();
    }
}
export declare class QualifiedName implements PossiblyQualifiedName, PublicValueType {
    constructor(value: string);
    get value(): string;
    static new_net_akehurst_language_base_api_QualifiedName(namespace: QualifiedName, name: SimpleName): QualifiedName;
    get isQualified(): boolean;
    get parts(): KtList<SimpleName>;
    get last(): SimpleName;
    get front(): QualifiedName;
    get asPossiblyQualified(): PossiblyQualifiedName;
    append(lastPart: SimpleName): QualifiedName;
    get simpleName(): SimpleName;
    get asImport(): Import;
    asQualifiedName(namespace: Nullable<QualifiedName>): QualifiedName;
    toString(): string;
    copy(value?: string): QualifiedName;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PossiblyQualifiedName["__doNotUseOrImplementIt"] & PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace QualifiedName.$metadata$ {
    const constructor: abstract new () => QualifiedName;
}
export declare class SimpleName implements PossiblyQualifiedName, PublicValueType {
    constructor(value: string);
    get value(): string;
    get simpleName(): SimpleName;
    asQualifiedName(namespace: Nullable<QualifiedName>): QualifiedName;
    toString(): string;
    copy(value?: string): SimpleName;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PossiblyQualifiedName["__doNotUseOrImplementIt"] & PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SimpleName.$metadata$ {
    const constructor: abstract new () => SimpleName;
}
export declare namespace SimpleName {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare interface PublicValueType {
    readonly value: any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.PublicValueType": unique symbol;
    };
}
export declare class Import implements PublicValueType {
    constructor(value: string);
    get value(): string;
    get asQualifiedName(): QualifiedName;
    toString(): string;
    copy(value?: string): Import;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Import.$metadata$ {
    const constructor: abstract new () => Import;
}
export declare interface Formatable {
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.Formatable": unique symbol;
    };
}
export declare interface OptionHolder {
    parent: Nullable<OptionHolder>;
    get<T>(name: string): Nullable<T>;
    clone(parent: Nullable<OptionHolder>): OptionHolder;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.OptionHolder": unique symbol;
    };
}
export declare interface Domain<NT extends Namespace<DT>, DT extends Definition<DT>> extends Formatable {
    readonly name: SimpleName;
    readonly options: OptionHolder;
    readonly namespace: KtList<NT>;
    readonly allDefinitions: KtList<DT>;
    readonly isEmpty: boolean;
    findNamespaceOrNull(qualifiedName: QualifiedName): Nullable<Namespace<DT>>;
    findDefinitionByQualifiedNameOrNull(qualifiedName: QualifiedName): Nullable<DT>;
    findFirstDefinitionByNameOrNull(simpleName: SimpleName): Nullable<DT>;
    findFirstDefinitionByPossiblyQualifiedNameOrNull(pqn: PossiblyQualifiedName): Nullable<DT>;
    resolveReference(reference: DefinitionReference<DT>): Nullable<DT>;
    addNamespace(value: NT): void;
    mergeNamespace(value: NT): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.Domain": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface Namespace<DT extends Definition<DT>> extends Formatable {
    readonly qualifiedName: QualifiedName;
    readonly options: OptionHolder;
    readonly import: KtList<Import>;
    readonly definition: KtList<DT>;
    readonly definitionByName: KtMap<SimpleName, DT>;
    resolveImports(domain: Domain<Namespace<DT>, DT>): void;
    findDefinitionOrNull(simpleName: SimpleName): Nullable<DT>;
    findOwnedDefinitionOrNull(simpleName: SimpleName): Nullable<DT>;
    addImport(value: Import): void;
    addDefinition(value: DT): void;
    merge(value: Namespace<DT>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.Namespace": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface DefinitionReference<DT extends Definition<DT>> {
    readonly localNamespace: Namespace<DT>;
    readonly nameOrQName: PossiblyQualifiedName;
    resolved: Nullable<DT>;
    resolveAs(resolved: DT): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.DefinitionReference": unique symbol;
    };
}
export declare interface Definition<DT extends Definition<DT>> extends Formatable {
    readonly namespace: Namespace<DT>;
    readonly name: SimpleName;
    readonly qualifiedName: QualifiedName;
    readonly options: OptionHolder;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.base.api.Definition": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare abstract class AglBase {
    static readonly getInstance: () => typeof AglBase.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglBase.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<any, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<LanguageObject<any, SentenceContext>>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get formatDomain(): AglFormatDomain;
        get styleDomain(): AglStyleDomain;
        get defaultTargetGoalRule(): string;
        get defaultTargetGrammar(): Grammar;
        get syntaxAnalyser(): Nullable<SyntaxAnalyser<any>>;
        get semanticAnalyser(): Nullable<SemanticAnalyser<any, SentenceContext>>;
        get completionProvider(): Nullable<CompletionProvider<any, SentenceContext>>;
        toString(): string;
        private constructor();
    }
}
export declare class BaseSemanticAnalyser implements SemanticAnalyser<any, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: any, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<any, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BaseSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => BaseSemanticAnalyser;
}
export declare class BaseSyntaxAnalyser extends SyntaxAnalyserByMethodRegistrationAbstract.$metadata$.constructor<any> {
    constructor();
    registerHandlers(): void;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BaseSyntaxAnalyser.$metadata$ {
    const constructor: abstract new () => BaseSyntaxAnalyser;
}
export declare class BaseCompletionProvider implements CompletionProvider<any, SentenceContext> {
    constructor();
    provide(nextExpected: KtSet<Spine>, options: CompletionProviderOptions<SentenceContext>): KtList<CompletionItem>;
    readonly __doNotUseOrImplementIt: CompletionProvider<any, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace BaseCompletionProvider.$metadata$ {
    const constructor: abstract new () => BaseCompletionProvider;
}
export declare interface ExpressionsDomain extends Domain<ExpressionsNamespace, FunctionDefinition>, Expression {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.ExpressionsDomain": unique symbol;
    } & Domain<ExpressionsNamespace, FunctionDefinition>["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"];
}
export declare interface ExpressionsNamespace extends Namespace<FunctionDefinition> {
    readonly function: KtList<FunctionDefinition>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.ExpressionsNamespace": unique symbol;
    } & Namespace<FunctionDefinition>["__doNotUseOrImplementIt"];
}
export declare interface FunctionDefinitionFloating {
    readonly name: SimpleName;
    readonly parameters: KtList<FunctionParameter>;
    readonly returnTypeReference: Nullable<TypeReference>;
    readonly body: Nullable<Expression>;
    readonly execution: Nullable<(p0: KtList<any /*UnknownType **/>) => Nullable<any>>;
    readonly executionSuspend: Nullable<any /*Suspend functions are not supported*/>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.FunctionDefinitionFloating": unique symbol;
    };
}
export declare interface FunctionDefinition extends FunctionDefinitionFloating, Definition<FunctionDefinition> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.FunctionDefinition": unique symbol;
    } & FunctionDefinitionFloating["__doNotUseOrImplementIt"] & Definition<FunctionDefinition>["__doNotUseOrImplementIt"];
}
export declare interface FunctionParameter {
    readonly name: string;
    readonly typeRef: TypeReference;
    readonly defaultValueExpression: Nullable<Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.FunctionParameter": unique symbol;
    };
}
export declare interface Expression extends Formatable {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.Expression": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface RootExpression extends Expression {
    readonly name: string;
    readonly isNothing: boolean;
    readonly isSelf: boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.RootExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface LiteralExpression extends Expression {
    readonly qualifiedTypeName: QualifiedName;
    readonly value: any;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.LiteralExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface CreateObjectExpression extends Expression {
    readonly possiblyQualifiedTypeName: PossiblyQualifiedName;
    readonly constructorArguments: KtList<VariableAssignmentStatement>;
    readonly propertyAssignments: KtList<VariableAssignmentStatement>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.CreateObjectExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface FunctionCall extends Expression {
    readonly possiblyQualifiedName: PossiblyQualifiedName;
    readonly arguments: KtList<Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.FunctionCall": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface CreateTupleExpression extends Expression {
    readonly propertyAssignments: KtList<VariableAssignmentStatement>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.CreateTupleExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface OnExpression extends Expression {
    readonly expression: Expression;
    readonly propertyAssignments: KtList<VariableAssignmentStatement>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.OnExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface NavigationExpression extends Expression {
    readonly start: Expression;
    readonly parts: KtList<NavigationPart>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.NavigationExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface NavigationPart {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.NavigationPart": unique symbol;
    };
}
export declare interface PropertyCall extends NavigationPart {
    readonly propertyName: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.PropertyCall": unique symbol;
    } & NavigationPart["__doNotUseOrImplementIt"];
}
export declare interface MethodCall extends NavigationPart {
    readonly methodName: string;
    readonly arguments: KtList<Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.MethodCall": unique symbol;
    } & NavigationPart["__doNotUseOrImplementIt"];
}
export declare interface LambdaExpression extends Expression {
    readonly variables: KtList<string>;
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.LambdaExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface StatementBlockExpression extends Expression {
    readonly assignment: KtList<VariableAssignmentStatement>;
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.StatementBlockExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface IndexOperation extends NavigationPart {
    readonly indices: KtList<Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.IndexOperation": unique symbol;
    } & NavigationPart["__doNotUseOrImplementIt"];
}
export declare interface VariableAssignmentStatement {
    readonly variable: VariableDefinition;
    readonly lhsGrammarRuleIndex: Nullable<number>;
    readonly rhs: Expression;
    asString(indent: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.VariableAssignmentStatement": unique symbol;
    };
}
export declare interface VariableDefinition {
    readonly name: string;
    readonly typeRef: Nullable<TypeReference>;
    asString(indent: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.VariableDefinition": unique symbol;
    };
}
export declare interface WithExpression extends Expression {
    readonly withContext: Expression;
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.WithExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface WhenExpression extends Expression {
    readonly options: KtList<WhenOption>;
    readonly elseOption: WhenOptionElse;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.WhenExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface WhenOption {
    readonly condition: Expression;
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.WhenOption": unique symbol;
    };
}
export declare interface WhenOptionElse {
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.WhenOptionElse": unique symbol;
    };
}
export declare interface TernaryConditionExpression extends Expression {
    readonly condition: Expression;
    readonly trueExpression: Expression;
    readonly falseExpression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.TernaryConditionExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface InfixExpression extends Expression {
    readonly expressions: KtList<Expression>;
    readonly operators: KtList<string>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.InfixExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface CastExpression extends Expression {
    readonly expression: Expression;
    readonly targetType: TypeReference;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.CastExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface TypeTestExpression extends Expression {
    readonly expression: Expression;
    readonly targetType: TypeReference;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.TypeTestExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface TypeReference {
    readonly possiblyQualifiedName: PossiblyQualifiedName;
    readonly typeArguments: KtList<TypeReference>;
    readonly isNullable: boolean;
    asString(indent: Indent, imports: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.TypeReference": unique symbol;
    };
}
export declare interface GroupExpression extends Expression {
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.expressions.api.GroupExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare class ExpressionsDomainDefault extends DomainAbstract.$metadata$.constructor<ExpressionsNamespace, FunctionDefinition> implements ExpressionsDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespaces?: KtList<ExpressionsNamespace>);
    get name(): SimpleName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ExpressionsDomain["__doNotUseOrImplementIt"] & DomainAbstract<ExpressionsNamespace, FunctionDefinition>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsDomainDefault.$metadata$ {
    const constructor: abstract new () => ExpressionsDomainDefault;
}
export declare class ExpressionsNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<FunctionDefinition> implements ExpressionsNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    get function(): KtList<FunctionDefinition>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ExpressionsNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<FunctionDefinition>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsNamespaceDefault.$metadata$ {
    const constructor: abstract new () => ExpressionsNamespaceDefault;
}
export declare abstract class FunctionDefinitionAbstract implements FunctionDefinitionFloating {
    constructor(name: SimpleName, parameters: KtList<FunctionParameter>, returnTypeReference: Nullable<TypeReference>, body: Nullable<Expression>);
    get name(): SimpleName;
    get parameters(): KtList<FunctionParameter>;
    get returnTypeReference(): Nullable<TypeReference>;
    get body(): Nullable<Expression>;
    get execution(): Nullable<(p0: KtList<any /*UnknownType **/>) => Nullable<any>>;
    set execution(value: Nullable<(p0: KtList<any /*UnknownType **/>) => Nullable<any>>);
    get executionSuspend(): Nullable<any /*Suspend functions are not supported*/>;
    set executionSuspend(value: Nullable<any /*Suspend functions are not supported*/>);
    readonly __doNotUseOrImplementIt: FunctionDefinitionFloating["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FunctionDefinitionAbstract.$metadata$ {
    const constructor: abstract new () => FunctionDefinitionAbstract;
}
export declare class FunctionDefinitionDefault extends FunctionDefinitionAbstract.$metadata$.constructor implements FunctionDefinitionFloating, FunctionDefinition {
    constructor(namespace: Namespace<FunctionDefinition>, name: SimpleName, parameters: KtList<FunctionParameter>, returnTypeReference: Nullable<TypeReference>, body: Expression);
    get namespace(): Namespace<FunctionDefinition>;
    get options(): OptionHolder;
    get qualifiedName(): QualifiedName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: FunctionDefinitionFloating["__doNotUseOrImplementIt"] & FunctionDefinitionAbstract["__doNotUseOrImplementIt"] & FunctionDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FunctionDefinitionDefault.$metadata$ {
    const constructor: abstract new () => FunctionDefinitionDefault;
}
export declare class FunctionParameterDefault implements FunctionParameter {
    constructor(name: string, typeRef: TypeReference, defaultValueExpression: Nullable<Expression>);
    get name(): string;
    get typeRef(): TypeReference;
    get defaultValueExpression(): Nullable<Expression>;
    readonly __doNotUseOrImplementIt: FunctionParameter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FunctionParameterDefault.$metadata$ {
    const constructor: abstract new () => FunctionParameterDefault;
}
export declare abstract class ExpressionAbstract implements Expression {
    constructor();
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: Expression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionAbstract.$metadata$ {
    const constructor: abstract new () => ExpressionAbstract;
}
export declare class CreateTupleExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements CreateTupleExpression {
    constructor(propertyAssignments: KtList<VariableAssignmentStatement>);
    get propertyAssignments(): KtList<VariableAssignmentStatement>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    copy(propertyAssignments?: KtList<VariableAssignmentStatement>): CreateTupleExpressionDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & CreateTupleExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CreateTupleExpressionDefault.$metadata$ {
    const constructor: abstract new () => CreateTupleExpressionDefault;
}
export declare class CreateObjectExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements CreateObjectExpression {
    constructor(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArguments: KtList<VariableAssignmentStatement>);
    get possiblyQualifiedTypeName(): PossiblyQualifiedName;
    get constructorArguments(): KtList<VariableAssignmentStatement>;
    get propertyAssignments(): KtList<VariableAssignmentStatement>;
    set propertyAssignments(value: KtList<VariableAssignmentStatement>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    copy(possiblyQualifiedTypeName?: PossiblyQualifiedName, constructorArguments?: KtList<VariableAssignmentStatement>): CreateObjectExpressionDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & CreateObjectExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CreateObjectExpressionDefault.$metadata$ {
    const constructor: abstract new () => CreateObjectExpressionDefault;
}
export declare class FunctionCallDefault extends ExpressionAbstract.$metadata$.constructor implements FunctionCall {
    constructor(possiblyQualifiedName: PossiblyQualifiedName, arguments: KtList<Expression>);
    get possiblyQualifiedName(): PossiblyQualifiedName;
    get arguments(): KtList<Expression>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    copy(possiblyQualifiedName?: PossiblyQualifiedName, arguments?: KtList<Expression>): FunctionCallDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & FunctionCall["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FunctionCallDefault.$metadata$ {
    const constructor: abstract new () => FunctionCallDefault;
}
export declare class WithExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements WithExpression {
    constructor(withContext: Expression, expression: Expression);
    get withContext(): Expression;
    get expression(): Expression;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & WithExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace WithExpressionDefault.$metadata$ {
    const constructor: abstract new () => WithExpressionDefault;
}
export declare class WhenExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements WhenExpression {
    constructor(options: KtList<WhenOption>, elseOption: WhenOptionElse);
    get options(): KtList<WhenOption>;
    get elseOption(): WhenOptionElse;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & WhenExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace WhenExpressionDefault.$metadata$ {
    const constructor: abstract new () => WhenExpressionDefault;
}
export declare class WhenOptionDefault implements WhenOption {
    constructor(condition: Expression, expression: Expression);
    get condition(): Expression;
    get expression(): Expression;
    toString(): string;
    readonly __doNotUseOrImplementIt: WhenOption["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace WhenOptionDefault.$metadata$ {
    const constructor: abstract new () => WhenOptionDefault;
}
export declare class WhenOptionElseDefault implements WhenOptionElse {
    constructor(expression: Expression);
    get expression(): Expression;
    toString(): string;
    readonly __doNotUseOrImplementIt: WhenOptionElse["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace WhenOptionElseDefault.$metadata$ {
    const constructor: abstract new () => WhenOptionElseDefault;
}
export declare class OnExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements OnExpression {
    constructor(expression: Expression);
    get expression(): Expression;
    get propertyAssignments(): KtList<VariableAssignmentStatement>;
    set propertyAssignments(value: KtList<VariableAssignmentStatement>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & OnExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OnExpressionDefault.$metadata$ {
    const constructor: abstract new () => OnExpressionDefault;
}
export declare class RootExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements RootExpression {
    constructor(name: string);
    get name(): string;
    get isNothing(): boolean;
    get isSelf(): boolean;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    copy(name?: string): RootExpressionDefault;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & RootExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RootExpressionDefault.$metadata$ {
    const constructor: abstract new () => RootExpressionDefault;
}
export declare namespace RootExpressionDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get NOTHING(): RootExpressionDefault;
            get SELF(): RootExpressionDefault;
            get ERROR(): RootExpressionDefault;
            private constructor();
        }
    }
}
export declare class LiteralExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements LiteralExpression {
    constructor(qualifiedTypeName: QualifiedName, value: any);
    get qualifiedTypeName(): QualifiedName;
    get value(): any;
    toString(): string;
    copy(qualifiedTypeName?: QualifiedName, value?: any): LiteralExpressionDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & LiteralExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LiteralExpressionDefault.$metadata$ {
    const constructor: abstract new () => LiteralExpressionDefault;
}
export declare class NavigationExpressionDefault extends ExpressionAbstract.$metadata$.constructor implements NavigationExpression {
    constructor(start: Expression, parts: KtList<NavigationPart>);
    get start(): Expression;
    get parts(): KtList<NavigationPart>;
    toString(): string;
    copy(start?: Expression, parts?: KtList<NavigationPart>): NavigationExpressionDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ExpressionAbstract["__doNotUseOrImplementIt"] & NavigationExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NavigationExpressionDefault.$metadata$ {
    const constructor: abstract new () => NavigationExpressionDefault;
}
export declare class PropertyCallDefault implements PropertyCall {
    constructor(propertyName: string);
    get propertyName(): string;
    toString(): string;
    copy(propertyName?: string): PropertyCallDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PropertyCall["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyCallDefault.$metadata$ {
    const constructor: abstract new () => PropertyCallDefault;
}
export declare class MethodCallDefault implements MethodCall {
    constructor(methodName: string, arguments: KtList<Expression>);
    get methodName(): string;
    get arguments(): KtList<Expression>;
    toString(): string;
    copy(methodName?: string, arguments?: KtList<Expression>): MethodCallDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: MethodCall["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MethodCallDefault.$metadata$ {
    const constructor: abstract new () => MethodCallDefault;
}
export declare class LambdaExpressionDefault implements LambdaExpression {
    constructor(variables: KtList<string>, expression: Expression);
    get variables(): KtList<string>;
    get expression(): Expression;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    copy(variables?: KtList<string>, expression?: Expression): LambdaExpressionDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: LambdaExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace LambdaExpressionDefault.$metadata$ {
    const constructor: abstract new () => LambdaExpressionDefault;
}
export declare class StatementBlockExpressionDefault implements StatementBlockExpression {
    constructor(assignment: KtList<VariableAssignmentStatement>, expression: Expression);
    get assignment(): KtList<VariableAssignmentStatement>;
    get expression(): Expression;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    copy(assignment?: KtList<VariableAssignmentStatement>, expression?: Expression): StatementBlockExpressionDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: StatementBlockExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StatementBlockExpressionDefault.$metadata$ {
    const constructor: abstract new () => StatementBlockExpressionDefault;
}
export declare class IndexOperationDefault implements IndexOperation {
    constructor(indices: KtList<Expression>);
    get indices(): KtList<Expression>;
    toString(): string;
    copy(indices?: KtList<Expression>): IndexOperationDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: IndexOperation["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IndexOperationDefault.$metadata$ {
    const constructor: abstract new () => IndexOperationDefault;
}
export declare class VariableAssignmentStatementDefault implements VariableAssignmentStatement {
    constructor(variable: VariableDefinition, lhsGrammarRuleIndex: Nullable<number>, rhs: Expression);
    get variable(): VariableDefinition;
    get lhsGrammarRuleIndex(): Nullable<number>;
    get rhs(): Expression;
    asString(indent: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: VariableAssignmentStatement["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VariableAssignmentStatementDefault.$metadata$ {
    const constructor: abstract new () => VariableAssignmentStatementDefault;
}
export declare class VariableDefinitionDefault implements VariableDefinition {
    constructor(name: string, typeRef: Nullable<TypeReference>);
    get name(): string;
    get typeRef(): Nullable<TypeReference>;
    asString(indent: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: VariableDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VariableDefinitionDefault.$metadata$ {
    const constructor: abstract new () => VariableDefinitionDefault;
}
export declare class TernaryConditionExpressionDefault implements TernaryConditionExpression {
    constructor(condition: Expression, trueExpression: Expression, falseExpression: Expression);
    get condition(): Expression;
    get trueExpression(): Expression;
    get falseExpression(): Expression;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: TernaryConditionExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TernaryConditionExpressionDefault.$metadata$ {
    const constructor: abstract new () => TernaryConditionExpressionDefault;
}
export declare class InfixExpressionDefault implements InfixExpression {
    constructor(expressions: KtList<Expression>, operators: KtList<string>);
    get expressions(): KtList<Expression>;
    get operators(): KtList<string>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: InfixExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace InfixExpressionDefault.$metadata$ {
    const constructor: abstract new () => InfixExpressionDefault;
}
export declare class CastExpressionDefault implements CastExpression {
    constructor(expression: Expression, targetType: TypeReference);
    get expression(): Expression;
    get targetType(): TypeReference;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: CastExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CastExpressionDefault.$metadata$ {
    const constructor: abstract new () => CastExpressionDefault;
}
export declare class TypeTestExpressionDefault implements TypeTestExpression {
    constructor(expression: Expression, targetType: TypeReference);
    get expression(): Expression;
    get targetType(): TypeReference;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: TypeTestExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeTestExpressionDefault.$metadata$ {
    const constructor: abstract new () => TypeTestExpressionDefault;
}
export declare class TypeReferenceDefault implements TypeReference {
    constructor(possiblyQualifiedName: PossiblyQualifiedName, typeArguments: KtList<TypeReference>, isNullable: boolean);
    get possiblyQualifiedName(): PossiblyQualifiedName;
    get typeArguments(): KtList<TypeReference>;
    get isNullable(): boolean;
    asString(indent: Indent, imports: KtList<Import>): string;
    toString(): string;
    copy(possiblyQualifiedName?: PossiblyQualifiedName, typeArguments?: KtList<TypeReference>, isNullable?: boolean): TypeReferenceDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: TypeReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeReferenceDefault.$metadata$ {
    const constructor: abstract new () => TypeReferenceDefault;
}
export declare class GroupExpressionDefault implements GroupExpression {
    constructor(expression: Expression);
    get expression(): Expression;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: GroupExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GroupExpressionDefault.$metadata$ {
    const constructor: abstract new () => GroupExpressionDefault;
}
export declare interface TypedObject {
    readonly accessor: ObjectGraphAccessorMutatorCommon;
    readonly self: any;
    readonly type: TypeInstance;
    getProperty(name: string): TypedObject;
    getPropertySuspend(name: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    setProperty(name: string, value: TypedObject): void;
    setPropertySuspend(name: string, value: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    executeMethod(name: string, argValues: KtList<TypedObject>): TypedObject;
    executeMethodSuspend(name: string, argValues: KtList<TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.TypedObject": unique symbol;
    };
}
export declare class EvaluationContext {
    constructor(parent: Nullable<EvaluationContext>, initialNamedValues: KtMap<string, TypedObject>);
    get parent(): Nullable<EvaluationContext>;
    get namedValues(): KtMap<string, TypedObject>;
    get self(): Nullable<TypedObject>;
    get executionTrace(): KtList<string>;
    getOrInParent(name: string): Nullable<TypedObject>;
    child(namedValues?: KtMap<string, TypedObject>): EvaluationContext;
    childSelf(self: TypedObject, namedValues?: KtMap<string, TypedObject>): EvaluationContext;
    setNamedValue(name: string, value: TypedObject): EvaluationContext;
    addExecutionTrace(trace: string): void;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EvaluationContext.$metadata$ {
    const constructor: abstract new () => EvaluationContext;
}
export declare namespace EvaluationContext {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            of(namedValues: KtMap<string, TypedObject>, parent?: Nullable<EvaluationContext>): EvaluationContext;
            ofSelf(self: TypedObject, namedValues?: KtMap<string, TypedObject>, parent?: Nullable<EvaluationContext>): EvaluationContext;
            private constructor();
        }
    }
}
export declare class ExecutionResult {
    constructor(value: Nullable<any>);
    get value(): Nullable<any>;
    copy(value?: Nullable<any>): ExecutionResult;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExecutionResult.$metadata$ {
    const constructor: abstract new () => ExecutionResult;
}
export declare interface ObjectGraph {
    readonly nodes: KtSet<TypedObject>;
    readonly edges: KtSet<ObjectGraphEdge>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.ObjectGraph": unique symbol;
    };
}
export declare interface ObjectGraphEdge {
    readonly source: TypedObject;
    readonly target: TypedObject;
    readonly property: PropertyDeclaration;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.ObjectGraphEdge": unique symbol;
    };
}
export declare interface ObjectGraphAccessorMutatorCommon {
    readonly issues: IssueHolder;
    readonly locationMap: LocationMap;
    typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    readonly createdStructuresByType: KtMap<TypeInstance, KtList<any>>;
    typeFor(obj: Nullable<any>, ifNotFound: TypeInstance): TypeInstance;
    toTypedObject(obj: Nullable<any>, ifNotFound: TypeInstance): TypedObject;
    untyped(typedObj: TypedObject): any;
    typedAs(obj: any, type: TypeInstance): TypedObject;
    isNothing(obj: TypedObject): boolean;
    equalTo(lhs: TypedObject, rhs: TypedObject): boolean;
    nothing(): TypedObject;
    any(value: any): TypedObject;
    valueOf(value: TypedObject): any;
    getFromListWithIndex(tobj: TypedObject, index: number): TypedObject;
    getFromMapWithKey(tobj: TypedObject, key: TypedObject): TypedObject;
    forEachIndexed(tobj: TypedObject, body: (p0: number, p1: TypedObject) => void): void;
    callFunction(functionName: string, args: KtList<TypedObject>, typeReferenceResolver: (p0: TypeReference) => TypeInstance): TypedObject;
    cast(tobj: TypedObject, newType: TypeInstance): TypedObject;
    createPrimitiveValue(qualifiedTypeName: QualifiedName, value: any): TypedObject;
    createTupleValue(typeArgs: KtList<TypeArgumentNamed>): TypedObject;
    createCollection(collectionType: TypeInstance, collection: any/* Iterable<TypedObject> */): TypedObject;
    createCollectionFromQualifiedName(qualifiedTypeName: QualifiedName, collection: any/* Iterable<TypedObject> */): TypedObject;
    collectionUnion(collection1: TypedObject, collection2: TypedObject): TypedObject;
    getCompositeGraphFrom(resultGraphIdentity: string, roots: KtList<TypedObject>): ObjectGraph;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.ObjectGraphAccessorMutatorCommon": unique symbol;
    };
}
export declare interface ExternalGetter {
    typeFor(obj: any, ifNotFound: TypeInstance): TypeInstance;
    createStructure(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>): Nullable<any>;
    getProperty(obj: any, propertyName: string): Nullable<any>;
    setProperty(obj: any, propertyName: string, value: Nullable<any>): void;
    createStructureSuspend(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>): Nullable<any>;
    getPropertySuspend(obj: any, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.ExternalGetter": unique symbol;
    };
}
export declare interface FunctionLib {
    readonly declaration: KtMap<string, FunctionDefinitionFloating>;
    findFirstFunctionNamed(functionName: string): Nullable<FunctionDefinitionFloating>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.FunctionLib": unique symbol;
    };
}
export declare interface ObjectGraphAccessorMutator extends ObjectGraphAccessorMutatorCommon {
    readonly primitiveExecutor: any/* PrimitiveExecutor */;
    readonly externalGetter: ExternalGetter;
    readonly functionLib: FunctionLib;
    createLambdaValue(lambda: (p0: TypedObject) => TypedObject): TypedObject;
    createStructureValue(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>): TypedObject;
    getProperty(tobj: TypedObject, propertyName: string): TypedObject;
    executeMethod(tobj: TypedObject, methodName: string, args: KtList<TypedObject>): TypedObject;
    setProperty(tobj: TypedObject, propertyName: string, value: TypedObject): void;
    createLambdaValueSuspend(lambda: any /*Suspend functions are not supported*/, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    createStructureValueSuspend(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    getPropertySuspend(tobj: TypedObject, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    setPropertySuspend(tobj: TypedObject, propertyName: string, value: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    executeMethodSuspend(tobj: TypedObject, methodName: string, args: KtList<TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.ObjectGraphAccessorMutator": unique symbol;
    } & ObjectGraphAccessorMutatorCommon["__doNotUseOrImplementIt"];
}
export declare interface ExternalGetterSuspending {
    typeFor(obj: any): TypeInstance;
    createStructure(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    getProperty(obj: any, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.objectgraph.api.ExternalGetterSuspending": unique symbol;
    };
}
export declare abstract class AglExpressions {
    static readonly getInstance: () => typeof AglExpressions.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglExpressions.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<Expression, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get TYPES_API_NS_QN(): string;
        get TYPES_ASM_NS_QN(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get formatDomain(): AglFormatDomain;
        get styleDomain(): AglStyleDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): ExpressionsSyntaxAnalyser;
        get semanticAnalyser(): ExpressionsSemanticAnalyser;
        get completionProvider(): ExpressionsCompletionProvider;
        toString(): string;
        private constructor();
    }
}
export declare function objectInstance(_this_: SingletonType): any;
export declare function constructDataType(_this_: DataType, constructorArgs: Array<Nullable<any>>): any;
export declare function constructValueType(_this_: ValueType, value: any): any;
export declare function get(_this_: PropertyDeclaration, obj: any): Nullable<any>;
export declare function set(_this_: PropertyDeclaration, obj: any, value: Nullable<any>): void;
export declare function valueOf<E extends unknown/* Enum<E> */>(_this_: EnumType, name: string): Nullable<any>/* Nullable<Enum<E>> */;
export declare class ExpressionTypeResolver {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, contextNamespace: TypesNamespace, issues: IssueHolder);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get contextNamespace(): TypesNamespace;
    get issues(): IssueHolder;
    typeFor(expression: Expression, self: TypeInstance): TypeInstance;
    typeOfExpressionStr(expression: string, self: TypeDefinition): TypeInstance;
    typeOfExpressionFor(_this_: Expression, self: TypeInstance): TypeInstance;
    typeOfLiteralExpressionFor(_this_: LiteralExpression, self: TypeInstance): TypeInstance;
    typeOfRootExpressionFor(_this_: RootExpression, self: TypeInstance): TypeInstance;
    typeOfNavigationExpressionFor(_this_: NavigationExpression, self: TypeInstance): TypeInstance;
    typeOfNavigationPartFor(_this_: NavigationPart, self: TypeInstance): TypeInstance;
    lastPropertyDeclarationFor(expr: NavigationExpression, self: TypeInstance): Nullable<PropertyDeclaration>;
    typeOfPropertyCallFor(_this_: PropertyCall, self: Nullable<TypeInstance>): TypeInstance;
    typeOfMethodCallFor(_this_: MethodCall, self: Nullable<TypeInstance>): TypeInstance;
    typeOfIndexOperationFor(_this_: IndexOperation, self: Nullable<TypeInstance>): TypeInstance;
    typeOfWithExpressionFor(_this_: WithExpression, self: TypeInstance): TypeInstance;
    typeOfWhenExpressionFor(_this_: WhenExpression, self: TypeInstance): TypeInstance;
    typeOfTernaryConditionFor(_this_: TernaryConditionExpression, self: TypeInstance): TypeInstance;
    typeOfInfixExpressionFor(_this_: InfixExpression, self: TypeInstance): TypeInstance;
    typeOfCreateObjectExpressionFor(_this_: CreateObjectExpression, self: TypeInstance): TypeInstance;
    typeOfCreateTupleExpressionFor(_this_: CreateTupleExpression, self: TypeInstance): TypeInstance;
    typeOfOnExpressionFor(_this_: OnExpression, self: TypeInstance): TypeInstance;
    typeOfLambdaExpressionFor(_this_: LambdaExpression, self: TypeInstance): TypeInstance;
    typeOfCastExpressionFor(_this_: CastExpression, self: TypeInstance): TypeInstance;
    typeOfGroupExpressionFor(_this_: GroupExpression, self: TypeInstance): TypeInstance;
    typeOfTypeReference(_this_: TypeReference): TypeInstance;
    commonSuperTypeOf(types: KtList<TypeInstance>): TypeInstance;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionTypeResolver.$metadata$ {
    const constructor: abstract new () => ExpressionTypeResolver;
}
export declare class ExpressionsCompletionProvider extends CompletionProviderAbstract.$metadata$.constructor<Expression, SentenceContext> {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsCompletionProvider.$metadata$ {
    const constructor: abstract new () => ExpressionsCompletionProvider;
}
export declare class ExpressionsInterpreterOverTypedObject {
    constructor(objectGraph: ObjectGraphAccessorMutator);
    get objectGraph(): ObjectGraphAccessorMutator;
    get issues(): IssueHolder;
    get locationMap(): LocationMap;
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    issueError(item: Nullable<any>, message: string, data?: Nullable<any>): void;
    issueErrorReturnNothing(item: Nullable<any>, message: string, data?: Nullable<any>): TypedObject;
    issueWarn(item: Nullable<any>, message: string, data?: Nullable<any>): void;
    evaluateStr(evc: EvaluationContext, expression: string): TypedObject;
    evaluateExpression(evc: EvaluationContext, expression: Expression): TypedObject;
    protected evaluateFunctionCall(evc: EvaluationContext, expression: FunctionCall): TypedObject;
    evaluateTypeReference(typeReference: TypeReference): TypeInstance;
    constructObject(evc: EvaluationContext, expression: CreateObjectExpression): TypedObject;
    propertyAssignmentBlock(evc: EvaluationContext, self: TypedObject, propertyAssignments: KtList<VariableAssignmentStatement>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsInterpreterOverTypedObject.$metadata$ {
    const constructor: abstract new () => ExpressionsInterpreterOverTypedObject;
}
export declare class ExpressionsInterpreterOverTypedObjectSuspending {
    constructor(objectGraph: ObjectGraphAccessorMutator);
    get objectGraph(): ObjectGraphAccessorMutator;
    get issues(): IssueHolder;
    get typeModel(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    evaluateStr(evc: EvaluationContext, expression: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    evaluateExpression(evc: EvaluationContext, expression: Expression, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    evaluateTypeReference(typeReference: TypeReference): TypeInstance;
    constructObject(evc: EvaluationContext, expression: CreateObjectExpression, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    propertyAssignmentBlock(evc: EvaluationContext, self: TypedObject, propertyAssignments: KtList<VariableAssignmentStatement>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsInterpreterOverTypedObjectSuspending.$metadata$ {
    const constructor: abstract new () => ExpressionsInterpreterOverTypedObjectSuspending;
}
export declare class ExpressionsSemanticAnalyser implements SemanticAnalyser<Expression, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: Expression, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<Expression, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => ExpressionsSemanticAnalyser;
}
export declare class ExpressionsSyntaxAnalyser extends SyntaxAnalyserByMethodRegistrationAbstract.$metadata$.constructor<Expression> {
    constructor();
    get extendsSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    registerHandlers(): void;
    unit(nodeInfo: SpptDataNodeInfo, children: KtList<Nullable<any>>, sentence: Sentence): ExpressionsDomain;
    namespace(nodeInfo: SpptDataNodeInfo, children: KtList<Nullable<any>>, sentence: Sentence): ExpressionsNamespace;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExpressionsSyntaxAnalyser.$metadata$ {
    const constructor: abstract new () => ExpressionsSyntaxAnalyser;
}
export declare namespace ExpressionsSyntaxAnalyser {
    class PropertyValue {
        constructor(asmObject: any, value: string);
        get asmObject(): any;
        get value(): string;
        copy(asmObject?: any, value?: string): ExpressionsSyntaxAnalyser.PropertyValue;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace PropertyValue.$metadata$ {
        const constructor: abstract new () => PropertyValue;
    }
}
export declare abstract class StdFunctionLibForAsmSimple {
    static readonly getInstance: () => typeof StdFunctionLibForAsmSimple.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StdFunctionLibForAsmSimple.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements FunctionLib {
        get declaration(): KtMap<string, FunctionDefinitionFloating>;
        findFirstFunctionNamed(functionName: string): Nullable<FunctionDefinitionFloating>;
        readonly __doNotUseOrImplementIt: FunctionLib["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare class ExternalGetterAsmSimple implements ExternalGetter {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, crossReferenceDomain: Nullable<CrossReferenceDomain>, issues: IssueHolder, locationMap: LocationMap);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get crossReferenceDomain(): Nullable<CrossReferenceDomain>;
    get issues(): IssueHolder;
    get locationMap(): LocationMap;
    typeFor(obj: any, ifNotFound: TypeInstance): TypeInstance;
    createStructure(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>): AsmValue;
    getProperty(obj: any, propertyName: string): Nullable<any>;
    setProperty(obj: any, propertyName: string, value: Nullable<any>): void;
    createStructureSuspend(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>): Nullable<any>;
    getPropertySuspend(obj: any, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    readonly __doNotUseOrImplementIt: ExternalGetter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExternalGetterAsmSimple.$metadata$ {
    const constructor: abstract new () => ExternalGetterAsmSimple;
}
export declare class ObjectGraphAccessorMutatorAsmSimple implements ObjectGraphAccessorMutator {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, issues: IssueHolder, locationMap: LocationMap, externalGetter?: ExternalGetter, primitiveExecutor?: any/* PrimitiveExecutor */, functionLib?: FunctionLib);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    set typesDomain(value: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */);
    get issues(): IssueHolder;
    get locationMap(): LocationMap;
    get externalGetter(): ExternalGetter;
    get primitiveExecutor(): any/* PrimitiveExecutor */;
    get functionLib(): FunctionLib;
    get createdStructuresByType(): KtMutableMap<TypeInstance, KtList<AsmValue>>;
    typeFor(obj: Nullable<any>, ifNotFound: TypeInstance): TypeInstance;
    toTypedObject(obj: Nullable<any>, ifNotFound: TypeInstance): TypedObject;
    untyped(typedObj: TypedObject): any;
    typedAs(obj: any, type: TypeInstance): TypedObject;
    isNothing(obj: TypedObject): boolean;
    equalTo(lhs: TypedObject, rhs: TypedObject): boolean;
    nothing(): TypedObject;
    any(value: any): TypedObject;
    createPrimitiveValue(qualifiedTypeName: QualifiedName, value: any): TypedObject;
    createTupleValue(typeArgs: KtList<TypeArgumentNamed>): TypedObject;
    createStructureValue(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>): TypedObject;
    createStructureValueSuspend(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    createCollection(collectionType: TypeInstance, collection: any/* Iterable<TypedObject> */): TypedObject;
    createCollectionFromQualifiedName(qualifiedTypeName: QualifiedName, collection: any/* Iterable<TypedObject> */): TypedObject;
    valueOf(value: TypedObject): any;
    getFromListWithIndex(tobj: TypedObject, index: number): TypedObject;
    getFromMapWithKey(tobj: TypedObject, key: TypedObject): TypedObject;
    forEachIndexed(tobj: TypedObject, body: (p0: number, p1: TypedObject) => void): void;
    cast(tobj: TypedObject, newType: TypeInstance): TypedObject;
    getCompositeGraphFrom(resultGraphIdentity: string, roots: KtList<TypedObject>): ObjectGraph;
    createLambdaValue(lambda: (p0: TypedObject) => TypedObject): TypedObject;
    createLambdaValueSuspend(lambda: any /*Suspend functions are not supported*/, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    getProperty(tobj: TypedObject, propertyName: string): TypedObject;
    getPropertySuspend(tobj: TypedObject, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    setProperty(tobj: TypedObject, propertyName: string, value: TypedObject): void;
    collectionUnion(collection1: TypedObject, collection2: TypedObject): TypedObject;
    setPropertySuspend(tobj: TypedObject, propertyName: string, value: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    executeMethod(tobj: TypedObject, methodName: string, args: KtList<TypedObject>): TypedObject;
    executeMethodSuspend(tobj: TypedObject, methodName: string, args: KtList<TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    callFunction(functionName: string, args: KtList<TypedObject>, typeReferenceResolver: (p0: TypeReference) => TypeInstance): TypedObject;
    readonly __doNotUseOrImplementIt: ObjectGraphAccessorMutator["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphAccessorMutatorAsmSimple.$metadata$ {
    const constructor: abstract new () => ObjectGraphAccessorMutatorAsmSimple;
}
export declare class ObjectGraphAsmSimple implements ObjectGraph {
    constructor(identity: string, nodes: KtSet<TypedObject>, edges: KtSet<ObjectGraphEdge>);
    get identity(): string;
    get nodes(): KtSet<TypedObject>;
    get edges(): KtSet<ObjectGraphEdge>;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: ObjectGraph["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphAsmSimple.$metadata$ {
    const constructor: abstract new () => ObjectGraphAsmSimple;
}
export declare class ObjectGraphEdgeSimple implements ObjectGraphEdge {
    constructor(source: TypedObject, target: TypedObject, property: PropertyDeclaration);
    get source(): TypedObject;
    get target(): TypedObject;
    get property(): PropertyDeclaration;
    copy(source?: TypedObject, target?: TypedObject, property?: PropertyDeclaration): ObjectGraphEdgeSimple;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ObjectGraphEdge["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphEdgeSimple.$metadata$ {
    const constructor: abstract new () => ObjectGraphEdgeSimple;
}
export declare class ExternalGetterByReflection implements ExternalGetter {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, issues: IssueHolder);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get issues(): IssueHolder;
    typeFor(obj: any, ifNotFound: TypeInstance): TypeInstance;
    createStructure(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>): Nullable<any>;
    getProperty(obj: any, propertyName: string): Nullable<any>;
    setProperty(obj: any, propertyName: string, value: Nullable<any>): void;
    createStructureSuspend(qualifiedName: QualifiedName, constructorArgs: KtMap<string, any>): Nullable<any>;
    getPropertySuspend(obj: any, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    readonly __doNotUseOrImplementIt: ExternalGetter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ExternalGetterByReflection.$metadata$ {
    const constructor: abstract new () => ExternalGetterByReflection;
}
export declare class ObjectGraphAccessorMutatorByReflection extends ObjectGraphAccessorMutatorCommonByReflectionAbstract.$metadata$.constructor<any> implements ObjectGraphAccessorMutator {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, issues: IssueHolder, locationMap: LocationMap, externalGetter?: ExternalGetter, primitiveExecutor?: any/* PrimitiveExecutor */, functionLib?: FunctionLib);
    get externalGetter(): ExternalGetter;
    get primitiveExecutor(): any/* PrimitiveExecutor */;
    get functionLib(): FunctionLib;
    typeFor(obj: Nullable<any>, ifNotFound: TypeInstance): TypeInstance;
    createLambdaValue(lambda: (p0: TypedObject) => TypedObject): TypedObject;
    executeMethod(tobj: TypedObject, methodName: string, args: KtList<TypedObject>): TypedObject;
    callFunction(functionName: string, args: KtList<TypedObject>, typeReferenceResolver: (p0: TypeReference) => TypeInstance): TypedObject;
    createStructureValue(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>): TypedObject;
    getProperty(tobj: TypedObject, propertyName: string): TypedObject;
    setProperty(tobj: TypedObject, propertyName: string, value: TypedObject): void;
    createLambdaValueSuspend(lambda: any /*Suspend functions are not supported*/, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    createStructureValueSuspend(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    getPropertySuspend(tobj: TypedObject, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    setPropertySuspend(tobj: TypedObject, propertyName: string, value: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    executeMethodSuspend(tobj: TypedObject, methodName: string, args: KtList<TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    readonly __doNotUseOrImplementIt: ObjectGraphAccessorMutatorCommonByReflectionAbstract<any>["__doNotUseOrImplementIt"] & ObjectGraphAccessorMutator["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphAccessorMutatorByReflection.$metadata$ {
    const constructor: abstract new () => ObjectGraphAccessorMutatorByReflection;
}
export declare class ObjectGraphAny implements ObjectGraph {
    constructor(nodes: KtSet<TypedObject>, edges: KtSet<ObjectGraphEdge>);
    get nodes(): KtSet<TypedObject>;
    get edges(): KtSet<ObjectGraphEdge>;
    readonly __doNotUseOrImplementIt: ObjectGraph["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphAny.$metadata$ {
    const constructor: abstract new () => ObjectGraphAny;
}
export declare class ObjectGraphEdgeAny implements ObjectGraphEdge {
    constructor(source: TypedObject, target: TypedObject, property: PropertyDeclaration);
    get source(): TypedObject;
    get target(): TypedObject;
    get property(): PropertyDeclaration;
    copy(source?: TypedObject, target?: TypedObject, property?: PropertyDeclaration): ObjectGraphEdgeAny;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ObjectGraphEdge["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphEdgeAny.$metadata$ {
    const constructor: abstract new () => ObjectGraphEdgeAny;
}
export declare abstract class ObjectGraphAccessorMutatorCommonByReflectionAbstract<StructureType extends any> implements ObjectGraphAccessorMutator {
    constructor(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, issues: IssueHolder, locationMap: LocationMap);
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    set typesDomain(value: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */);
    get issues(): IssueHolder;
    get locationMap(): LocationMap;
    get createdStructuresByType(): KtMutableMap<TypeInstance, KtList<StructureType>>;
    issueError(obj: Nullable<any>, message: string): void;
    issueErrorReturnNothing(obj: Nullable<any>, message: string): TypedObject;
    issueWarningReturnNothing(obj: Nullable<any>, message: string): TypedObject;
    untypedAny(possiblyTypedObject: Nullable<any>): any;
    toTypedObject(obj: Nullable<any>, ifNotFound: TypeInstance): TypedObject;
    untyped(typedObj: TypedObject): any;
    typedAs(obj: any, type: TypeInstance): TypedObject;
    isNothing(obj: TypedObject): boolean;
    equalTo(lhs: TypedObject, rhs: TypedObject): boolean;
    nothing(): TypedObject;
    any(value: any): TypedObject;
    createPrimitiveValue(qualifiedTypeName: QualifiedName, value: any): TypedObject;
    createTupleValue(typeArgs: KtList<TypeArgumentNamed>): TypedObject;
    createCollection(collectionType: TypeInstance, collection: any/* Iterable<TypedObject> */): TypedObject;
    createCollectionFromQualifiedName(qualifiedTypeName: QualifiedName, collection: any/* Iterable<TypedObject> */): TypedObject;
    valueOf(value: TypedObject): any;
    getFromListWithIndex(tobj: TypedObject, index: number): TypedObject;
    getFromMapWithKey(tobj: TypedObject, key: TypedObject): TypedObject;
    forEachIndexed(tobj: TypedObject, body: (p0: number, p1: TypedObject) => void): void;
    collectionUnion(collection1: TypedObject, collection2: TypedObject): TypedObject;
    cast(tobj: TypedObject, newType: TypeInstance): TypedObject;
    protected addCreatedStructure(type: TypeInstance, obj: StructureType): void;
    getCompositeGraphFrom(resultGraphIdentity: string, roots: KtList<TypedObject>): ObjectGraph;
    abstract get primitiveExecutor(): any/* PrimitiveExecutor */;
    abstract get externalGetter(): ExternalGetter;
    abstract get functionLib(): FunctionLib;
    abstract createLambdaValue(lambda: (p0: TypedObject) => TypedObject): TypedObject;
    abstract createStructureValue(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>): TypedObject;
    abstract getProperty(tobj: TypedObject, propertyName: string): TypedObject;
    abstract executeMethod(tobj: TypedObject, methodName: string, args: KtList<TypedObject>): TypedObject;
    abstract setProperty(tobj: TypedObject, propertyName: string, value: TypedObject): void;
    abstract createLambdaValueSuspend(lambda: any /*Suspend functions are not supported*/, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    abstract createStructureValueSuspend(possiblyQualifiedTypeName: PossiblyQualifiedName, constructorArgs: KtMap<string, TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    abstract getPropertySuspend(tobj: TypedObject, propertyName: string, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    abstract setPropertySuspend(tobj: TypedObject, propertyName: string, value: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    abstract executeMethodSuspend(tobj: TypedObject, methodName: string, args: KtList<TypedObject>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    abstract typeFor(obj: Nullable<any>, ifNotFound: TypeInstance): TypeInstance;
    abstract callFunction(functionName: string, args: KtList<TypedObject>, typeReferenceResolver: (p0: TypeReference) => TypeInstance): TypedObject;
    readonly __doNotUseOrImplementIt: ObjectGraphAccessorMutator["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectGraphAccessorMutatorCommonByReflectionAbstract.$metadata$ {
    const constructor: abstract new <StructureType extends any>() => ObjectGraphAccessorMutatorCommonByReflectionAbstract<StructureType>;
}
export declare function formatDomain(name: string, init: (p0: FormatModelBuilder) => void): AglFormatDomain;
export declare class FormatModelBuilder {
    constructor(name: SimpleName);
    get name(): SimpleName;
    namespace(qualifiedName: string, init: (p0: FormatNamespaceBuilder) => void): FormatNamespace;
    build(): AglFormatDomain;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatModelBuilder.$metadata$ {
    const constructor: abstract new () => FormatModelBuilder;
}
export declare class FormatNamespaceBuilder {
    constructor(qualifiedName: QualifiedName);
    get qualifiedName(): QualifiedName;
    build(): FormatNamespace;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatNamespaceBuilder.$metadata$ {
    const constructor: abstract new () => FormatNamespaceBuilder;
}
export declare class FormatExpressionBuilder {
    constructor(_asm: AsmSimple);
    literalString(value: string): void;
    build(): AsmStructure;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatExpressionBuilder.$metadata$ {
    const constructor: abstract new () => FormatExpressionBuilder;
}
export declare interface AglFormatDomain extends Domain<FormatNamespace, FormatDefinition> {
    readonly defaultWhiteSpace: string;
    readonly rules: KtMap<SimpleName, AglFormatRule>;
    findFirstFunctionDefinitionByNameOrNull(functionName: SimpleName): Nullable<FormatFunctionDefinition>;
    findFirstFormatSetDefinitionByNameOrNull(formatSetName: PossiblyQualifiedName): Nullable<FormatSet>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.AglFormatDomain": unique symbol;
    } & Domain<FormatNamespace, FormatDefinition>["__doNotUseOrImplementIt"];
}
export declare interface FormatNamespace extends Namespace<FormatDefinition> {
    readonly function: KtList<FormatFunctionDefinition>;
    readonly formatSet: KtList<FormatSet>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatNamespace": unique symbol;
    } & Namespace<FormatDefinition>["__doNotUseOrImplementIt"];
}
export declare interface FormatSetReference {
    readonly localNamespace: FormatNamespace;
    readonly nameOrQName: PossiblyQualifiedName;
    readonly resolved: Nullable<FormatSet>;
    resolveAs(resolved: FormatSet): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatSetReference": unique symbol;
    };
}
export declare interface FormatDefinition extends Definition<FormatDefinition> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatDefinition": unique symbol;
    } & Definition<FormatDefinition>["__doNotUseOrImplementIt"];
}
export declare interface FormatFunctionDefinition extends FormatDefinition, FunctionDefinitionFloating {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatFunctionDefinition": unique symbol;
    } & FormatDefinition["__doNotUseOrImplementIt"] & FunctionDefinitionFloating["__doNotUseOrImplementIt"];
}
export declare interface FormatSet extends FormatDefinition {
    readonly namespace: FormatNamespace;
    readonly extends: KtList<FormatSetReference>;
    readonly rules: KtList<AglFormatRule>;
    readonly allRules: KtList<AglFormatRule>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatSet": unique symbol;
    } & FormatDefinition["__doNotUseOrImplementIt"];
}
export declare interface AglFormatRule {
    readonly forTypeName: TypeReference;
    readonly formatExpression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.AglFormatRule": unique symbol;
    };
}
export declare interface FormatExpression extends Expression {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatExpression": unique symbol;
    } & Expression["__doNotUseOrImplementIt"];
}
export declare interface FormatEmbeddedExpression extends FormatExpression {
    readonly expression: Expression;
    readonly via: Nullable<PossiblyQualifiedName>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatEmbeddedExpression": unique symbol;
    } & FormatExpression["__doNotUseOrImplementIt"];
}
export declare interface FormatExpressionTemplate extends FormatExpression {
    readonly content: KtList<TemplateElement>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatExpressionTemplate": unique symbol;
    } & FormatExpression["__doNotUseOrImplementIt"];
}
export declare interface FormatExpressionWhen extends FormatExpression {
    readonly options: KtList<FormatWhenOption>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatExpressionWhen": unique symbol;
    } & FormatExpression["__doNotUseOrImplementIt"];
}
export declare interface FormatWhenOption extends WhenOption {
    readonly format: FormatExpression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatWhenOption": unique symbol;
    } & WhenOption["__doNotUseOrImplementIt"];
}
export declare interface FormatWhenOptionElse extends WhenOptionElse {
    readonly format: FormatExpression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatWhenOptionElse": unique symbol;
    } & WhenOptionElse["__doNotUseOrImplementIt"];
}
export declare interface FormatSeparatedList {
    readonly listExpression: Expression;
    readonly separator: Expression;
    readonly via: Nullable<PossiblyQualifiedName>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.FormatSeparatedList": unique symbol;
    };
}
export declare interface TemplateElement {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.TemplateElement": unique symbol;
    };
}
export declare interface TemplateElementText extends TemplateElement {
    readonly text: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.TemplateElementText": unique symbol;
    } & TemplateElement["__doNotUseOrImplementIt"];
}
export declare interface TemplateElementExpressionProperty extends TemplateElement {
    readonly propertyName: string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.TemplateElementExpressionProperty": unique symbol;
    } & TemplateElement["__doNotUseOrImplementIt"];
}
export declare interface TemplateElementExpressionList extends TemplateElement {
    readonly formatSeparatedList: FormatSeparatedList;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.TemplateElementExpressionList": unique symbol;
    } & TemplateElement["__doNotUseOrImplementIt"];
}
export declare interface TemplateElementExpressionListSeparator {
    readonly value: string;
    readonly isNamedOfValue: boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.TemplateElementExpressionListSeparator": unique symbol;
    };
}
export declare interface TemplateElementExpressionEmbedded extends TemplateElement {
    readonly expression: FormatExpression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.formatter.api.TemplateElementExpressionEmbedded": unique symbol;
    } & TemplateElement["__doNotUseOrImplementIt"];
}
export declare class FormatDomainDefault extends DomainAbstract.$metadata$.constructor<FormatNamespace, FormatDefinition> implements AglFormatDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespaces?: KtList<FormatNamespace>);
    get name(): SimpleName;
    get defaultWhiteSpace(): string;
    get rules(): KtMutableMap<SimpleName, AglFormatRule>;
    addRule(typeName: SimpleName): void;
    findFirstFunctionDefinitionByNameOrNull(functionName: SimpleName): Nullable<FormatFunctionDefinition>;
    findFirstFormatSetDefinitionByNameOrNull(formatSetName: PossiblyQualifiedName): Nullable<FormatSet>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: AglFormatDomain["__doNotUseOrImplementIt"] & DomainAbstract<FormatNamespace, FormatDefinition>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatDomainDefault.$metadata$ {
    const constructor: abstract new () => FormatDomainDefault;
}
export declare namespace FormatDomainDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            fromGrammar(grammarDomain: GrammarDomain, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ProcessResult<AglFormatDomain>;
            fromString(sentenceContext: SentenceContext, formatModelStr: FormatString): ProcessResult<AglFormatDomain>;
            private constructor();
        }
    }
}
export declare class FormatNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<FormatDefinition> implements FormatNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    get function(): KtList<FormatFunctionDefinition>;
    get formatSet(): KtList<FormatSet>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: FormatNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<FormatDefinition>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatNamespaceDefault.$metadata$ {
    const constructor: abstract new () => FormatNamespaceDefault;
}
export declare class FormatSetReferenceDefault implements FormatSetReference {
    constructor(localNamespace: FormatNamespace, nameOrQName: PossiblyQualifiedName);
    get localNamespace(): FormatNamespace;
    get nameOrQName(): PossiblyQualifiedName;
    get resolved(): Nullable<FormatSet>;
    set resolved(value: Nullable<FormatSet>);
    resolveAs(resolved: FormatSet): void;
    readonly __doNotUseOrImplementIt: FormatSetReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatSetReferenceDefault.$metadata$ {
    const constructor: abstract new () => FormatSetReferenceDefault;
}
export declare class FormatFunctionDefinitionDefault extends FunctionDefinitionAbstract.$metadata$.constructor implements FunctionDefinitionFloating, FormatFunctionDefinition {
    constructor(namespace: Namespace<FormatDefinition>, name: SimpleName, parameters: KtList<FunctionParameter>, returnTypeReference: Nullable<TypeReference>, body: Expression);
    get namespace(): Namespace<FormatDefinition>;
    get options(): OptionHolder;
    get qualifiedName(): QualifiedName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    get name(): SimpleName;
    readonly __doNotUseOrImplementIt: FunctionDefinitionFloating["__doNotUseOrImplementIt"] & FormatFunctionDefinition["__doNotUseOrImplementIt"] & FunctionDefinitionAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatFunctionDefinitionDefault.$metadata$ {
    const constructor: abstract new () => FormatFunctionDefinitionDefault;
}
export declare class FormatSetDefault extends DefinitionAbstract.$metadata$.constructor<FormatDefinition> implements FormatSet {
    constructor(namespace: FormatNamespace, name: SimpleName, _extends: KtList<FormatSetReference>, options: OptionHolder | undefined, rules: KtList<AglFormatRule>);
    get namespace(): FormatNamespace;
    get name(): SimpleName;
    get extends(): KtList<FormatSetReference>;
    get options(): OptionHolder;
    get rules(): KtList<AglFormatRule>;
    get allRules(): KtList<AglFormatRule>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: FormatSet["__doNotUseOrImplementIt"] & DefinitionAbstract<FormatDefinition>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatSetDefault.$metadata$ {
    const constructor: abstract new () => FormatSetDefault;
}
export declare class AglFormatRuleDefault implements AglFormatRule {
    constructor(forTypeName: TypeReference, formatExpression: Expression);
    get forTypeName(): TypeReference;
    get formatExpression(): Expression;
    readonly __doNotUseOrImplementIt: AglFormatRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglFormatRuleDefault.$metadata$ {
    const constructor: abstract new () => AglFormatRuleDefault;
}
export declare class FormatExpressionWhenDefault implements FormatExpressionWhen {
    constructor(options: KtList<FormatWhenOption>);
    get options(): KtList<FormatWhenOption>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: FormatExpressionWhen["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatExpressionWhenDefault.$metadata$ {
    const constructor: abstract new () => FormatExpressionWhenDefault;
}
export declare class FormatWhenOptionDefault implements FormatWhenOption {
    constructor(condition: Expression, format: FormatExpression);
    get condition(): Expression;
    get format(): FormatExpression;
    get expression(): Expression;
    readonly __doNotUseOrImplementIt: FormatWhenOption["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatWhenOptionDefault.$metadata$ {
    const constructor: abstract new () => FormatWhenOptionDefault;
}
export declare class FormatWhenOptionElseDefault implements FormatWhenOptionElse {
    constructor(format: FormatExpression);
    get format(): FormatExpression;
    get expression(): Expression;
    readonly __doNotUseOrImplementIt: FormatWhenOptionElse["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatWhenOptionElseDefault.$metadata$ {
    const constructor: abstract new () => FormatWhenOptionElseDefault;
}
export declare class FormatEmbeddedExpressionDefault implements FormatEmbeddedExpression {
    constructor(expression: Expression, via: Nullable<PossiblyQualifiedName>);
    get expression(): Expression;
    get via(): Nullable<PossiblyQualifiedName>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: FormatEmbeddedExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatEmbeddedExpressionDefault.$metadata$ {
    const constructor: abstract new () => FormatEmbeddedExpressionDefault;
}
export declare class FormatExpressionTemplateDefault implements FormatExpressionTemplate {
    constructor(content: KtList<TemplateElement>);
    get content(): KtList<TemplateElement>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: FormatExpressionTemplate["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatExpressionTemplateDefault.$metadata$ {
    const constructor: abstract new () => FormatExpressionTemplateDefault;
}
export declare class FormatSeparatedListDefault implements FormatSeparatedList {
    constructor(listExpression: Expression, separator: Expression, via: Nullable<PossiblyQualifiedName>);
    get listExpression(): Expression;
    get separator(): Expression;
    get via(): Nullable<PossiblyQualifiedName>;
    toString(): string;
    readonly __doNotUseOrImplementIt: FormatSeparatedList["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatSeparatedListDefault.$metadata$ {
    const constructor: abstract new () => FormatSeparatedListDefault;
}
export declare class TemplateElementTextDefault implements TemplateElementText {
    constructor(text: string);
    get text(): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: TemplateElementText["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateElementTextDefault.$metadata$ {
    const constructor: abstract new () => TemplateElementTextDefault;
}
export declare class TemplateElementExpressionPropertyDefault implements TemplateElementExpressionProperty {
    constructor(propertyName: string);
    get propertyName(): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: TemplateElementExpressionProperty["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateElementExpressionPropertyDefault.$metadata$ {
    const constructor: abstract new () => TemplateElementExpressionPropertyDefault;
}
export declare class TemplateElementExpressionListDefault implements TemplateElementExpressionList {
    constructor(formatSeparatedList: FormatSeparatedList);
    get formatSeparatedList(): FormatSeparatedList;
    toString(): string;
    readonly __doNotUseOrImplementIt: TemplateElementExpressionList["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateElementExpressionListDefault.$metadata$ {
    const constructor: abstract new () => TemplateElementExpressionListDefault;
}
export declare class TemplateElementExpressionListSeparatorDefault implements TemplateElementExpressionListSeparator {
    constructor(value: string, isNamedOfValue: boolean);
    get value(): string;
    get isNamedOfValue(): boolean;
    copy(value?: string, isNamedOfValue?: boolean): TemplateElementExpressionListSeparatorDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: TemplateElementExpressionListSeparator["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateElementExpressionListSeparatorDefault.$metadata$ {
    const constructor: abstract new () => TemplateElementExpressionListSeparatorDefault;
}
export declare class TemplateElementExpressionEmbeddedDefault implements TemplateElementExpressionEmbedded {
    constructor(expression: FormatExpression);
    get expression(): FormatExpression;
    toString(): string;
    readonly __doNotUseOrImplementIt: TemplateElementExpressionEmbedded["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateElementExpressionEmbeddedDefault.$metadata$ {
    const constructor: abstract new () => TemplateElementExpressionEmbeddedDefault;
}
export declare abstract class AglFormat {
    static readonly getInstance: () => typeof AglFormat.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglFormat.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<AglFormatDomain, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get goalRuleName(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get komposite(): string;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get styleDomain(): AglStyleDomain;
        get formatDomain(): AglFormatDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): Nullable<SyntaxAnalyser<AglFormatDomain>>;
        get semanticAnalyser(): Nullable<SemanticAnalyser<AglFormatDomain, SentenceContext>>;
        get completionProvider(): Nullable<CompletionProvider<AglFormatDomain, SentenceContext>>;
        private constructor();
    }
}
export declare class AglFormatCompletionProvider extends CompletionProviderAbstract.$metadata$.constructor<AglFormatDomain, SentenceContext> {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglFormatCompletionProvider.$metadata$ {
    const constructor: abstract new () => AglFormatCompletionProvider;
}
export declare class AglFormatSemanticAnalyser implements SemanticAnalyser<AglFormatDomain, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: AglFormatDomain, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<AglFormatDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglFormatSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => AglFormatSemanticAnalyser;
}
export declare namespace AglFormatSemanticAnalyser {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            findFormatSetOrNull(context: SentenceContext, localNamespace: QualifiedName, nameOrQName: PossiblyQualifiedName): Nullable<FormatSet>;
            private constructor();
        }
    }
}
export declare class FormatterOverAsmSimple implements Formatter {
    constructor(formatDomain: AglFormatDomain, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, issues: IssueHolder, locationMap: LocationMap);
    get formatDomain(): AglFormatDomain;
    get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
    get issues(): IssueHolder;
    formatSelf(formatSetName: PossiblyQualifiedName, self: any): FormatResult;
    format(formatSetName: PossiblyQualifiedName, evc: EvaluationContext): FormatResult;
    readonly __doNotUseOrImplementIt: Formatter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatterOverAsmSimple.$metadata$ {
    const constructor: abstract new () => FormatterOverAsmSimple;
}
export declare class FormatterOverTypedObject extends ExpressionsInterpreterOverTypedObject.$metadata$.constructor implements Formatter {
    constructor(formatDomain: AglFormatDomain, objectGraph: ObjectGraphAccessorMutator);
    get formatDomain(): AglFormatDomain;
    findRuleFor(formatSetName: PossiblyQualifiedName, type: TypeInstance): Nullable<AglFormatRule>;
    formatSelf(formatSetName: PossiblyQualifiedName, self: any): FormatResult;
    format(formatSetName: PossiblyQualifiedName, evc: EvaluationContext): FormatResult;
    formatEvaluateExpression(formatSetName: PossiblyQualifiedName, evc: EvaluationContext, expression: Expression): TypedObject;
    evaluateExpression(evc: EvaluationContext, expression: Expression): TypedObject;
    protected evaluateFunctionCall(evc: EvaluationContext, expression: FunctionCall): TypedObject;
    readonly __doNotUseOrImplementIt: Formatter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FormatterOverTypedObject.$metadata$ {
    const constructor: abstract new () => FormatterOverTypedObject;
}
export declare namespace FormatterOverTypedObject {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get EVC_FORMAT_SET_NAME(): string;
            get EOL_NAME(): string;
            get prefixMatchPattern(): any/* Regex */;
            joinToStringSuspend<T>(_this_: any/* Iterable<T> */, separator: any/* CharSequence */ | undefined, prefix: any/* CharSequence */ | undefined, postfix: any/* CharSequence */ | undefined, limit: number | undefined, truncated: any/* CharSequence */ | undefined, transform: Nullable<any /*Suspend functions are not supported*/> | undefined, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
            private constructor();
        }
    }
}
export declare class GrammarDomainDefault extends DomainAbstract.$metadata$.constructor<GrammarNamespace, Grammar> implements GrammarDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespace?: KtList<GrammarNamespace>);
    get name(): SimpleName;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    get primary(): Nullable<Grammar>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: GrammarDomain["__doNotUseOrImplementIt"] & DomainAbstract<GrammarNamespace, Grammar>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarDomainDefault.$metadata$ {
    const constructor: abstract new () => GrammarDomainDefault;
}
/** @deprecated Just use a GrammarDomain */
export declare function asGrammarDomain(_this_: Grammar): GrammarDomain;
export declare class GrammarNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<Grammar> implements GrammarNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: GrammarNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<Grammar>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarNamespaceDefault.$metadata$ {
    const constructor: abstract new () => GrammarNamespaceDefault;
}
export declare class GrammarDefault extends GrammarAbstract.$metadata$.constructor {
    constructor(namespace: GrammarNamespace, name: SimpleName, options: OptionHolder);
    get defaultGoalRule(): GrammarRule;
    findAllResolvedEmbeddedGrammars(found?: KtSet<Grammar>): KtSet<Grammar>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarDefault.$metadata$ {
    const constructor: abstract new () => GrammarDefault;
}
export declare namespace GrammarDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            fromString(): void;
            private constructor();
        }
    }
}
export declare class GrammarReferenceDefault implements GrammarReference {
    constructor(localNamespace: Namespace<Grammar>, nameOrQName: PossiblyQualifiedName);
    get localNamespace(): Namespace<Grammar>;
    get nameOrQName(): PossiblyQualifiedName;
    get resolved(): Nullable<Grammar>;
    set resolved(value: Nullable<Grammar>);
    resolveAs(resolved: Grammar): void;
    copy(localNamespace?: Namespace<Grammar>, nameOrQName?: PossiblyQualifiedName): GrammarReferenceDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: GrammarReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarReferenceDefault.$metadata$ {
    const constructor: abstract new () => GrammarReferenceDefault;
}
export declare abstract class GrammarAbstract implements Grammar {
    constructor(namespace: GrammarNamespace, name: SimpleName, options: OptionHolder);
    get namespace(): GrammarNamespace;
    get name(): SimpleName;
    get options(): OptionHolder;
    get selfReference(): GrammarReferenceDefault;
    get qualifiedName(): QualifiedName;
    get extends(): KtMutableList<GrammarReference>;
    get grammarRule(): KtMutableList<GrammarRule>;
    get preferenceRule(): KtMutableList<PreferenceRule>;
    get allGrammarReferencesInRules(): KtList<GrammarReference>;
    get extendsResolved(): KtList<Grammar>;
    get allExtends(): OrderedSet<GrammarReference>;
    get allExtendsResolved(): OrderedSet<Grammar>;
    get directInheritedGrammarRule(): KtList<GrammarRule>;
    get allGrammarRule(): KtList<GrammarRule>;
    get directInheritedResolvedGrammarRule(): OrderedSet<GrammarRule>;
    get allInheritedResolvedGrammarRule(): OrderedSet<GrammarRule>;
    get resolvedGrammarRule(): OrderedSet<GrammarRule>;
    get allResolvedGrammarRule(): OrderedSet<GrammarRule>;
    get allResolvedTerminal(): KtSet<Terminal>;
    get allResolvedSkipTerminal(): KtSet<Terminal>;
    get allResolvedNonTerminalRule(): KtSet<GrammarRule>;
    get allResolvedPreferenceRuleRule(): OrderedSet<PreferenceRule>;
    get allResolvedEmbeddedRules(): KtSet<Embedded>;
    get allResolvedEmbeddedGrammars(): KtSet<Grammar>;
    findOwnedGrammarRuleOrNull(ruleName: GrammarRuleName): Nullable<GrammarRule>;
    findAllSuperGrammarRule(ruleName: GrammarRuleName): KtList<GrammarRule>;
    findAllGrammarRuleList(ruleName: GrammarRuleName): KtList<GrammarRule>;
    findAllResolvedGrammarRule(ruleName: GrammarRuleName): Nullable<GrammarRule>;
    findAllResolvedTerminalRule(terminalPattern: EscapedPattern): Terminal;
    findAllResolvedEmbeddedGrammars(found?: KtSet<Grammar>): KtSet<Grammar>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    abstract get defaultGoalRule(): GrammarRule;
    readonly __doNotUseOrImplementIt: Grammar["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarAbstract.$metadata$ {
    const constructor: abstract new () => GrammarAbstract;
}
export declare abstract class GrammarItemAbstract implements GrammarItem {
    constructor();
    abstract get grammar(): Grammar;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: GrammarItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarItemAbstract.$metadata$ {
    const constructor: abstract new () => GrammarItemAbstract;
}
export declare abstract class GrammarRuleAbstract extends GrammarItemAbstract.$metadata$.constructor implements GrammarRule {
    constructor();
    get qualifiedName(): QualifiedName;
    get isOneEmbedded(): boolean;
    get compressedLeaf(): Terminal;
    abstract get grammar(): Grammar;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    abstract get name(): GrammarRuleName;
    abstract get isOverride(): boolean;
    abstract get isSkip(): boolean;
    abstract get isLeaf(): boolean;
    abstract get rhs(): RuleItem;
    readonly __doNotUseOrImplementIt: GrammarItemAbstract["__doNotUseOrImplementIt"] & GrammarRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarRuleAbstract.$metadata$ {
    const constructor: abstract new () => GrammarRuleAbstract;
}
export declare namespace GrammarRuleAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        namespace type {
            class CompressedLeafRule extends RuleItemAbstract.$metadata$.constructor implements Terminal {
                constructor(id: string, unescapedValue: UnescapedValue, isPattern: boolean);
                get id(): string;
                get unescapedValue(): UnescapedValue;
                get isPattern(): boolean;
                get isLiteral(): boolean;
                get escapedValue(): EscapedValue;
                get allTerminal(): KtSet<Terminal>;
                get allNonTerminal(): KtSet<NonTerminal>;
                get allEmbedded(): KtSet<Embedded>;
                get firstTerminal(): KtSet<Terminal>;
                get firstTangible(): KtSet<TangibleItem>;
                get firstTangibleRecursive(): KtSet<Terminal>;
                get firstConcatenationRecursive(): KtSet<Concatenation>;
                setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
                subItem(index: number): RuleItem;
                itemsForChild(childNumber: number): KtSet<RuleItem>;
                readonly __doNotUseOrImplementIt: Terminal["__doNotUseOrImplementIt"] & RuleItemAbstract["__doNotUseOrImplementIt"];
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace CompressedLeafRule.$metadata$ {
                const constructor: abstract new () => CompressedLeafRule;
            }
        }
        abstract class constructor {
            compressRuleItem(compressedName: string, item: RuleItem): GrammarRuleAbstract.Companion.CompressedLeafRule;
            private constructor();
        }
    }
}
export declare class NormalRuleDefault extends GrammarRuleAbstract.$metadata$.constructor implements NormalRule {
    constructor(grammar: Grammar, name: GrammarRuleName, isSkip: boolean, isLeaf: boolean);
    get grammar(): Grammar;
    get name(): GrammarRuleName;
    get isSkip(): boolean;
    get isLeaf(): boolean;
    get isOverride(): boolean;
    get rhs(): RuleItem;
    set rhs(value: RuleItem);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: GrammarRuleAbstract["__doNotUseOrImplementIt"] & NormalRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NormalRuleDefault.$metadata$ {
    const constructor: abstract new () => NormalRuleDefault;
}
export declare class OverrideRuleDefault extends GrammarRuleAbstract.$metadata$.constructor implements OverrideRule {
    constructor(grammar: Grammar, name: GrammarRuleName, isSkip: boolean, isLeaf: boolean, overrideKind: OverrideKind);
    get grammar(): Grammar;
    get name(): GrammarRuleName;
    get isSkip(): boolean;
    get isLeaf(): boolean;
    get overrideKind(): OverrideKind;
    get isOverride(): boolean;
    get overriddenRhs(): RuleItem;
    set overriddenRhs(value: RuleItem);
    get rhs(): RuleItem;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    copy(grammar?: Grammar, name?: GrammarRuleName, isSkip?: boolean, isLeaf?: boolean, overrideKind?: OverrideKind): OverrideRuleDefault;
    readonly __doNotUseOrImplementIt: GrammarRuleAbstract["__doNotUseOrImplementIt"] & OverrideRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OverrideRuleDefault.$metadata$ {
    const constructor: abstract new () => OverrideRuleDefault;
}
export declare class PreferenceRuleDefault extends GrammarItemAbstract.$metadata$.constructor implements PreferenceRule {
    constructor(grammar: Grammar, forItem: SimpleItem, optionList: KtList<PreferenceOption>);
    get grammar(): Grammar;
    get forItem(): SimpleItem;
    get optionList(): KtList<PreferenceOption>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    copy(grammar?: Grammar, forItem?: SimpleItem, optionList?: KtList<PreferenceOption>): PreferenceRuleDefault;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: GrammarItemAbstract["__doNotUseOrImplementIt"] & PreferenceRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PreferenceRuleDefault.$metadata$ {
    const constructor: abstract new () => PreferenceRuleDefault;
}
export declare class PreferenceOptionDefault implements PreferenceOption {
    constructor(spine: Spine, choiceIndicator: ChoiceIndicator, choiceNumber: number, onTerminals: KtList<SimpleItem>, associativity: Associativity);
    get spine(): Spine;
    get choiceIndicator(): ChoiceIndicator;
    get choiceNumber(): number;
    get onTerminals(): KtList<SimpleItem>;
    get associativity(): Associativity;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(spine?: Spine, choiceIndicator?: ChoiceIndicator, choiceNumber?: number, onTerminals?: KtList<SimpleItem>, associativity?: Associativity): PreferenceOptionDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PreferenceOption["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PreferenceOptionDefault.$metadata$ {
    const constructor: abstract new () => PreferenceOptionDefault;
}
export declare class SpineDefault implements Spine {
    constructor(parts: KtList<NonTerminal>);
    get parts(): KtList<NonTerminal>;
    copy(parts?: KtList<NonTerminal>): SpineDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Spine["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SpineDefault.$metadata$ {
    const constructor: abstract new () => SpineDefault;
}
export declare abstract class RuleItemAbstract implements RuleItem {
    protected constructor();
    protected get _owningRule(): Nullable<GrammarRule>;
    protected set _owningRule(value: Nullable<GrammarRule>);
    get owningRule(): GrammarRule;
    get index(): Nullable<KtList<number>>;
    set index(value: Nullable<KtList<number>>);
    abstract get allTerminal(): KtSet<Terminal>;
    abstract get allNonTerminal(): KtSet<NonTerminal>;
    abstract get allEmbedded(): KtSet<Embedded>;
    abstract get firstTerminal(): KtSet<Terminal>;
    abstract get firstTangible(): KtSet<TangibleItem>;
    abstract get firstTangibleRecursive(): KtSet<TangibleItem>;
    abstract get firstConcatenationRecursive(): KtSet<Concatenation>;
    abstract subItem(index: number): RuleItem;
    abstract itemsForChild(childNumber: number): KtSet<RuleItem>;
    abstract setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    readonly __doNotUseOrImplementIt: RuleItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleItemAbstract.$metadata$ {
    const constructor: abstract new () => RuleItemAbstract;
}
export declare class ConcatenationDefault extends RuleItemAbstract.$metadata$.constructor implements Concatenation {
    constructor(items: KtList<RuleItem>);
    get items(): KtList<RuleItem>;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangible(): KtSet<TangibleItem>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleItemAbstract["__doNotUseOrImplementIt"] & Concatenation["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ConcatenationDefault.$metadata$ {
    const constructor: abstract new () => ConcatenationDefault;
}
export declare abstract class ChoiceAbstract extends RuleItemAbstract.$metadata$.constructor implements Choice {
    protected constructor(alternative: KtList<RuleItem>);
    get alternative(): KtList<RuleItem>;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangible(): KtSet<TangibleItem>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleItemAbstract["__doNotUseOrImplementIt"] & Choice["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChoiceAbstract.$metadata$ {
    const constructor: abstract new () => ChoiceAbstract;
}
export declare class ChoiceLongestDefault extends ChoiceAbstract.$metadata$.constructor implements ChoiceLongest {
    constructor(alternative: KtList<RuleItem>);
    get alternative(): KtList<RuleItem>;
    readonly __doNotUseOrImplementIt: ChoiceAbstract["__doNotUseOrImplementIt"] & ChoiceLongest["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChoiceLongestDefault.$metadata$ {
    const constructor: abstract new () => ChoiceLongestDefault;
}
export declare class ChoicePriorityDefault extends ChoiceAbstract.$metadata$.constructor implements ChoicePriority {
    constructor(alternative: KtList<RuleItem>);
    get alternative(): KtList<RuleItem>;
    readonly __doNotUseOrImplementIt: ChoiceAbstract["__doNotUseOrImplementIt"] & ChoicePriority["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChoicePriorityDefault.$metadata$ {
    const constructor: abstract new () => ChoicePriorityDefault;
}
export declare class ChoiceAmbiguousDefault extends ChoiceAbstract.$metadata$.constructor implements ChoiceAmbiguous {
    constructor(alternative: KtList<RuleItem>);
    get alternative(): KtList<RuleItem>;
    readonly __doNotUseOrImplementIt: ChoiceAbstract["__doNotUseOrImplementIt"] & ChoiceAmbiguous["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChoiceAmbiguousDefault.$metadata$ {
    const constructor: abstract new () => ChoiceAmbiguousDefault;
}
export declare abstract class ConcatenationItemAbstract extends RuleItemAbstract.$metadata$.constructor implements ConcatenationItem {
    protected constructor();
    abstract get allEmbedded(): KtSet<Embedded>;
    abstract get firstTerminal(): KtSet<Terminal>;
    abstract get firstTangible(): KtSet<TangibleItem>;
    abstract get firstTangibleRecursive(): KtSet<TangibleItem>;
    abstract get firstConcatenationRecursive(): KtSet<Concatenation>;
    abstract subItem(index: number): RuleItem;
    abstract itemsForChild(childNumber: number): KtSet<RuleItem>;
    abstract setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    readonly __doNotUseOrImplementIt: RuleItemAbstract["__doNotUseOrImplementIt"] & ConcatenationItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ConcatenationItemAbstract.$metadata$ {
    const constructor: abstract new () => ConcatenationItemAbstract;
}
export declare class OptionalItemDefault extends ConcatenationItemAbstract.$metadata$.constructor implements OptionalItem {
    constructor(item: RuleItem);
    get item(): RuleItem;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangible(): KtSet<TangibleItem>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    toString(): string;
    readonly __doNotUseOrImplementIt: ConcatenationItemAbstract["__doNotUseOrImplementIt"] & OptionalItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OptionalItemDefault.$metadata$ {
    const constructor: abstract new () => OptionalItemDefault;
}
export declare abstract class SimpleItemAbstract extends ConcatenationItemAbstract.$metadata$.constructor implements SimpleItem {
    protected constructor();
    abstract get allEmbedded(): KtSet<Embedded>;
    abstract get firstTerminal(): KtSet<Terminal>;
    abstract get firstTangible(): KtSet<TangibleItem>;
    abstract get firstTangibleRecursive(): KtSet<TangibleItem>;
    abstract get firstConcatenationRecursive(): KtSet<Concatenation>;
    abstract subItem(index: number): RuleItem;
    abstract itemsForChild(childNumber: number): KtSet<RuleItem>;
    abstract setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    readonly __doNotUseOrImplementIt: ConcatenationItemAbstract["__doNotUseOrImplementIt"] & SimpleItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SimpleItemAbstract.$metadata$ {
    const constructor: abstract new () => SimpleItemAbstract;
}
export declare class GroupDefault extends SimpleItemAbstract.$metadata$.constructor implements Group {
    constructor(groupedContent: RuleItem);
    get groupedContent(): RuleItem;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangible(): KtSet<TangibleItem>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    toString(): string;
    readonly __doNotUseOrImplementIt: SimpleItemAbstract["__doNotUseOrImplementIt"] & Group["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GroupDefault.$metadata$ {
    const constructor: abstract new () => GroupDefault;
}
export declare abstract class TangibleItemAbstract extends SimpleItemAbstract.$metadata$.constructor implements TangibleItem {
    protected constructor();
    get firstTangible(): KtSet<TangibleItem>;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    abstract get allEmbedded(): KtSet<Embedded>;
    abstract get firstTerminal(): KtSet<Terminal>;
    abstract get firstTangibleRecursive(): KtSet<TangibleItem>;
    abstract get firstConcatenationRecursive(): KtSet<Concatenation>;
    abstract subItem(index: number): RuleItem;
    abstract setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    readonly __doNotUseOrImplementIt: SimpleItemAbstract["__doNotUseOrImplementIt"] & TangibleItem["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TangibleItemAbstract.$metadata$ {
    const constructor: abstract new () => TangibleItemAbstract;
}
export declare class EmptyRuleDefault extends TangibleItemAbstract.$metadata$.constructor implements EmptyRule {
    constructor();
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangibleRecursive(): KtSet<Terminal>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    toString(): string;
    readonly __doNotUseOrImplementIt: TangibleItemAbstract["__doNotUseOrImplementIt"] & EmptyRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EmptyRuleDefault.$metadata$ {
    const constructor: abstract new () => EmptyRuleDefault;
}
export declare class TerminalDefault extends TangibleItemAbstract.$metadata$.constructor implements Terminal {
    constructor(escapedValue: EscapedValue, isPattern: boolean);
    get escapedValue(): EscapedValue;
    get isPattern(): boolean;
    get id(): string;
    get unescapedValue(): UnescapedValue;
    get isLiteral(): boolean;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangibleRecursive(): KtSet<Terminal>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    toString(): string;
    readonly __doNotUseOrImplementIt: TangibleItemAbstract["__doNotUseOrImplementIt"] & Terminal["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TerminalDefault.$metadata$ {
    const constructor: abstract new () => TerminalDefault;
}
export declare class NonTerminalDefault extends TangibleItemAbstract.$metadata$.constructor implements NonTerminal {
    constructor(targetGrammar: Nullable<GrammarReference>, ruleReference: GrammarRuleName);
    get targetGrammar(): Nullable<GrammarReference>;
    get ruleReference(): GrammarRuleName;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    referencedRuleOrNull(targetGrammar: Grammar): Nullable<GrammarRule>;
    referencedRule(targetGrammar: Grammar): GrammarRule;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    toString(): string;
    readonly __doNotUseOrImplementIt: TangibleItemAbstract["__doNotUseOrImplementIt"] & NonTerminal["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace NonTerminalDefault.$metadata$ {
    const constructor: abstract new () => NonTerminalDefault;
}
export declare class EmbeddedDefault extends TangibleItemAbstract.$metadata$.constructor implements Embedded {
    constructor(embeddedGoalName: GrammarRuleName, embeddedGrammarReference: GrammarReference);
    get embeddedGoalName(): GrammarRuleName;
    get embeddedGrammarReference(): GrammarReference;
    get resolvedGrammarRule(): Nullable<GrammarRule>;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    get firstTerminal(): KtSet<Terminal>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    referencedRule(targetGrammar: Grammar): GrammarRule;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    toString(): string;
    readonly __doNotUseOrImplementIt: TangibleItemAbstract["__doNotUseOrImplementIt"] & Embedded["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EmbeddedDefault.$metadata$ {
    const constructor: abstract new () => EmbeddedDefault;
}
export declare abstract class ListOfItemsAbstract extends ConcatenationItemAbstract.$metadata$.constructor implements ListOfItems {
    protected constructor();
    get firstTerminal(): KtSet<Terminal>;
    get firstTangible(): KtSet<TangibleItem>;
    get firstTangibleRecursive(): KtSet<TangibleItem>;
    get firstConcatenationRecursive(): KtSet<Concatenation>;
    abstract get allEmbedded(): KtSet<Embedded>;
    abstract subItem(index: number): RuleItem;
    abstract itemsForChild(childNumber: number): KtSet<RuleItem>;
    abstract setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    abstract get min(): number;
    abstract get max(): number;
    abstract get item(): RuleItem;
    readonly __doNotUseOrImplementIt: ConcatenationItemAbstract["__doNotUseOrImplementIt"] & ListOfItems["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ListOfItemsAbstract.$metadata$ {
    const constructor: abstract new () => ListOfItemsAbstract;
}
export declare class SimpleListDefault extends ListOfItemsAbstract.$metadata$.constructor implements SimpleList {
    constructor(min: number, max: number, item: RuleItem);
    get min(): number;
    get max(): number;
    get item(): RuleItem;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    toString(): string;
    readonly __doNotUseOrImplementIt: ListOfItemsAbstract["__doNotUseOrImplementIt"] & SimpleList["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SimpleListDefault.$metadata$ {
    const constructor: abstract new () => SimpleListDefault;
}
export declare class SeparatedListDefault extends ListOfItemsAbstract.$metadata$.constructor implements SeparatedList {
    constructor(min: number, max: number, item: RuleItem, separator: RuleItem);
    get min(): number;
    get max(): number;
    get item(): RuleItem;
    get separator(): RuleItem;
    get allTerminal(): KtSet<Terminal>;
    get allNonTerminal(): KtSet<NonTerminal>;
    get allEmbedded(): KtSet<Embedded>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    toString(): string;
    readonly __doNotUseOrImplementIt: ListOfItemsAbstract["__doNotUseOrImplementIt"] & SeparatedList["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SeparatedListDefault.$metadata$ {
    const constructor: abstract new () => SeparatedListDefault;
}
export declare interface GrammarDomain extends Domain<GrammarNamespace, Grammar> {
    readonly primary: Nullable<Grammar>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.GrammarDomain": unique symbol;
    } & Domain<GrammarNamespace, Grammar>["__doNotUseOrImplementIt"];
}
export declare interface GrammarNamespace extends Namespace<Grammar> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.GrammarNamespace": unique symbol;
    } & Namespace<Grammar>["__doNotUseOrImplementIt"];
}
export declare interface GrammarItem extends Formatable {
    readonly grammar: Grammar;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.GrammarItem": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface GrammarReference {
    readonly localNamespace: Namespace<Grammar>;
    readonly nameOrQName: PossiblyQualifiedName;
    readonly resolved: Nullable<Grammar>;
    resolveAs(resolved: Grammar): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.GrammarReference": unique symbol;
    };
}
export declare interface Grammar extends Definition<Grammar> {
    readonly selfReference: GrammarReference;
    readonly extends: KtList<GrammarReference>;
    readonly extendsResolved: KtList<Grammar>;
    readonly defaultGoalRule: GrammarRule;
    readonly grammarRule: KtList<GrammarRule>;
    readonly preferenceRule: KtList<PreferenceRule>;
    readonly allGrammarReferencesInRules: KtList<GrammarReference>;
    readonly allExtends: OrderedSet<GrammarReference>;
    readonly allExtendsResolved: OrderedSet<Grammar>;
    readonly directInheritedGrammarRule: KtList<GrammarRule>;
    readonly allGrammarRule: KtList<GrammarRule>;
    readonly directInheritedResolvedGrammarRule: OrderedSet<GrammarRule>;
    readonly allInheritedResolvedGrammarRule: OrderedSet<GrammarRule>;
    readonly resolvedGrammarRule: OrderedSet<GrammarRule>;
    readonly allResolvedGrammarRule: OrderedSet<GrammarRule>;
    readonly allResolvedPreferenceRuleRule: OrderedSet<PreferenceRule>;
    readonly allResolvedNonTerminalRule: KtSet<GrammarRule>;
    readonly allResolvedTerminal: KtSet<Terminal>;
    readonly allResolvedSkipTerminal: KtSet<Terminal>;
    readonly allResolvedEmbeddedRules: KtSet<Embedded>;
    readonly allResolvedEmbeddedGrammars: KtSet<Grammar>;
    findOwnedGrammarRuleOrNull(ruleName: GrammarRuleName): Nullable<GrammarRule>;
    findAllSuperGrammarRule(ruleName: GrammarRuleName): KtList<GrammarRule>;
    findAllGrammarRuleList(ruleName: GrammarRuleName): KtList<GrammarRule>;
    findAllResolvedGrammarRule(ruleName: GrammarRuleName): Nullable<GrammarRule>;
    findAllResolvedTerminalRule(terminalPattern: EscapedPattern): Terminal;
    findAllResolvedEmbeddedGrammars(found?: KtSet<Grammar>): KtSet<Grammar>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Grammar": unique symbol;
    } & Definition<Grammar>["__doNotUseOrImplementIt"];
}
export declare class GrammarRuleName implements PublicValueType {
    constructor(value: string);
    get value(): string;
    toString(): string;
    copy(value?: string): GrammarRuleName;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarRuleName.$metadata$ {
    const constructor: abstract new () => GrammarRuleName;
}
export declare interface PreferenceRule extends GrammarItem {
    readonly forItem: SimpleItem;
    readonly optionList: KtList<PreferenceOption>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.PreferenceRule": unique symbol;
    } & GrammarItem["__doNotUseOrImplementIt"];
}
export declare abstract class Associativity {
    private constructor();
    static get LEFT(): Associativity & {
        get name(): "LEFT";
        get ordinal(): 0;
    };
    static get RIGHT(): Associativity & {
        get name(): "RIGHT";
        get ordinal(): 1;
    };
    get name(): "LEFT" | "RIGHT";
    get ordinal(): 0 | 1;
    static values(): Array<Associativity>;
    static valueOf(value: string): Associativity;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Associativity.$metadata$ {
    const constructor: abstract new () => Associativity;
}
export declare abstract class ChoiceIndicator {
    private constructor();
    static get NONE(): ChoiceIndicator & {
        get name(): "NONE";
        get ordinal(): 0;
    };
    static get EMPTY(): ChoiceIndicator & {
        get name(): "EMPTY";
        get ordinal(): 1;
    };
    static get ITEM(): ChoiceIndicator & {
        get name(): "ITEM";
        get ordinal(): 2;
    };
    static get NUMBER(): ChoiceIndicator & {
        get name(): "NUMBER";
        get ordinal(): 3;
    };
    get name(): "NONE" | "EMPTY" | "ITEM" | "NUMBER";
    get ordinal(): 0 | 1 | 2 | 3;
    static values(): Array<ChoiceIndicator>;
    static valueOf(value: string): ChoiceIndicator;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ChoiceIndicator.$metadata$ {
    const constructor: abstract new () => ChoiceIndicator;
}
export declare interface PreferenceOption extends Formatable {
    readonly spine: Spine;
    readonly choiceIndicator: ChoiceIndicator;
    readonly choiceNumber: number;
    readonly onTerminals: KtList<SimpleItem>;
    readonly associativity: Associativity;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.PreferenceOption": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface Spine {
    readonly parts: KtList<NonTerminal>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Spine": unique symbol;
    };
}
export declare interface GrammarRule extends GrammarItem {
    readonly name: GrammarRuleName;
    readonly qualifiedName: QualifiedName;
    readonly isOverride: boolean;
    readonly isSkip: boolean;
    readonly isLeaf: boolean;
    readonly isOneEmbedded: boolean;
    readonly rhs: RuleItem;
    readonly compressedLeaf: Terminal;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.GrammarRule": unique symbol;
    } & GrammarItem["__doNotUseOrImplementIt"];
}
export declare interface NormalRule extends GrammarRule {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.NormalRule": unique symbol;
    } & GrammarRule["__doNotUseOrImplementIt"];
}
export declare abstract class OverrideKind {
    private constructor();
    static get REPLACE(): OverrideKind & {
        get name(): "REPLACE";
        get ordinal(): 0;
    };
    static get APPEND_ALTERNATIVE(): OverrideKind & {
        get name(): "APPEND_ALTERNATIVE";
        get ordinal(): 1;
    };
    static get SUBSTITUTION(): OverrideKind & {
        get name(): "SUBSTITUTION";
        get ordinal(): 2;
    };
    get name(): "REPLACE" | "APPEND_ALTERNATIVE" | "SUBSTITUTION";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<OverrideKind>;
    static valueOf(value: string): OverrideKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace OverrideKind.$metadata$ {
    const constructor: abstract new () => OverrideKind;
}
export declare interface OverrideRule extends GrammarRule {
    readonly overrideKind: OverrideKind;
    readonly overriddenRhs: RuleItem;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.OverrideRule": unique symbol;
    } & GrammarRule["__doNotUseOrImplementIt"];
}
export declare interface RuleItem {
    readonly owningRule: GrammarRule;
    readonly allTerminal: KtSet<Terminal>;
    readonly allNonTerminal: KtSet<NonTerminal>;
    readonly allEmbedded: KtSet<Embedded>;
    readonly firstTerminal: KtSet<Terminal>;
    readonly firstTangible: KtSet<TangibleItem>;
    readonly firstTangibleRecursive: KtSet<TangibleItem>;
    readonly firstConcatenationRecursive: KtSet<Concatenation>;
    subItem(index: number): RuleItem;
    itemsForChild(childNumber: number): KtSet<RuleItem>;
    setOwningRule(rule: GrammarRule, indices: KtList<number>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.RuleItem": unique symbol;
    };
}
export declare interface Choice extends RuleItem {
    readonly alternative: KtList<RuleItem>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Choice": unique symbol;
    } & RuleItem["__doNotUseOrImplementIt"];
}
export declare interface Concatenation extends RuleItem {
    readonly items: KtList<RuleItem>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Concatenation": unique symbol;
    } & RuleItem["__doNotUseOrImplementIt"];
}
export declare interface ConcatenationItem extends RuleItem {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.ConcatenationItem": unique symbol;
    } & RuleItem["__doNotUseOrImplementIt"];
}
export declare interface ChoiceLongest extends Choice {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.ChoiceLongest": unique symbol;
    } & Choice["__doNotUseOrImplementIt"];
}
export declare interface ChoicePriority extends Choice {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.ChoicePriority": unique symbol;
    } & Choice["__doNotUseOrImplementIt"];
}
export declare interface ChoiceAmbiguous extends Choice {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.ChoiceAmbiguous": unique symbol;
    } & Choice["__doNotUseOrImplementIt"];
}
export declare interface OptionalItem extends ConcatenationItem {
    readonly item: RuleItem;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.OptionalItem": unique symbol;
    } & ConcatenationItem["__doNotUseOrImplementIt"];
}
export declare interface SimpleItem extends ConcatenationItem {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.SimpleItem": unique symbol;
    } & ConcatenationItem["__doNotUseOrImplementIt"];
}
export declare interface ListOfItems extends ConcatenationItem {
    readonly min: number;
    readonly max: number;
    readonly item: RuleItem;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.ListOfItems": unique symbol;
    } & ConcatenationItem["__doNotUseOrImplementIt"];
}
export declare interface SimpleList extends ListOfItems {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.SimpleList": unique symbol;
    } & ListOfItems["__doNotUseOrImplementIt"];
}
export declare interface SeparatedList extends ListOfItems {
    readonly separator: RuleItem;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.SeparatedList": unique symbol;
    } & ListOfItems["__doNotUseOrImplementIt"];
}
export declare abstract class SeparatedListKind {
    private constructor();
    static get Flat(): SeparatedListKind & {
        get name(): "Flat";
        get ordinal(): 0;
    };
    static get Left(): SeparatedListKind & {
        get name(): "Left";
        get ordinal(): 1;
    };
    static get Right(): SeparatedListKind & {
        get name(): "Right";
        get ordinal(): 2;
    };
    get name(): "Flat" | "Left" | "Right";
    get ordinal(): 0 | 1 | 2;
    static values(): Array<SeparatedListKind>;
    static valueOf(value: string): SeparatedListKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SeparatedListKind.$metadata$ {
    const constructor: abstract new () => SeparatedListKind;
}
export declare interface Group extends SimpleItem {
    readonly groupedContent: RuleItem;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Group": unique symbol;
    } & SimpleItem["__doNotUseOrImplementIt"];
}
export declare interface TangibleItem extends SimpleItem {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.TangibleItem": unique symbol;
    } & SimpleItem["__doNotUseOrImplementIt"];
}
export declare interface EmptyRule extends TangibleItem {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.EmptyRule": unique symbol;
    } & TangibleItem["__doNotUseOrImplementIt"];
}
export declare interface Terminal extends TangibleItem {
    readonly id: string;
    readonly isLiteral: boolean;
    readonly isPattern: boolean;
    readonly escapedValue: EscapedValue;
    readonly unescapedValue: UnescapedValue;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Terminal": unique symbol;
    } & TangibleItem["__doNotUseOrImplementIt"];
}
export declare interface NonTerminal extends TangibleItem {
    readonly ruleReference: GrammarRuleName;
    readonly targetGrammar: Nullable<GrammarReference>;
    referencedRuleOrNull(targetGrammar: Grammar): Nullable<GrammarRule>;
    referencedRule(targetGrammar: Grammar): GrammarRule;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.NonTerminal": unique symbol;
    } & TangibleItem["__doNotUseOrImplementIt"];
}
export declare interface Embedded extends TangibleItem {
    readonly embeddedGoalName: GrammarRuleName;
    readonly embeddedGrammarReference: GrammarReference;
    referencedRule(targetGrammar: Grammar): GrammarRule;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammar.api.Embedded": unique symbol;
    } & TangibleItem["__doNotUseOrImplementIt"];
}
export declare function grammarDomain(name: string, namespaces: KtList<GrammarNamespace> | undefined, registry: Nullable<LanguageRegistry> | undefined, init: (p0: GrammarDomainBuilder) => void): GrammarDomain;
/** @deprecated use 'grammarModel' instead */
export declare function grammar(namespace: string, name: string, init: (p0: GrammarBuilder) => void): Grammar;
export declare class GrammarDomainBuilder {
    constructor(name: SimpleName, namespaces: KtList<GrammarNamespace>);
    option(key: string, value: string): void;
    namespace(qualifiedName: string, init: (p0: GrammarNamespaceBuilder) => void): void;
    build(): GrammarDomainDefault;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarDomainBuilder.$metadata$ {
    const constructor: abstract new () => GrammarDomainBuilder;
}
export declare class GrammarNamespaceBuilder {
    constructor(grammarDomain: GrammarDomain, qualifiedName: string);
    get grammarDomain(): GrammarDomain;
    option(key: string, value: string): void;
    import(qualifiedName: string): void;
    grammar(name: string, init: (p0: GrammarBuilder) => void): void;
    build(): GrammarNamespaceDefault;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarNamespaceBuilder.$metadata$ {
    const constructor: abstract new () => GrammarNamespaceBuilder;
}
export declare class GrammarBuilder {
    constructor(namespace: GrammarNamespace, name: SimpleName);
    extends(nameOrQName: string): void;
    extendsGrammar(extended: GrammarReference): void;
    empty(grammarRuleName: string, overrideKind?: Nullable<OverrideKind>, isSkip?: boolean, isLeaf?: boolean): void;
    choice(grammarRuleName: string, overrideKind: Nullable<OverrideKind> | undefined, isSkip: boolean | undefined, isLeaf: boolean | undefined, init: (p0: any/* ChoiceItemBuilder */) => void): void;
    concatenation(grammarRuleName: string, overrideKind: Nullable<OverrideKind> | undefined, isSkip: boolean | undefined, isLeaf: boolean | undefined, init: (p0: any/* ConcatenationItemBuilder */) => void): void;
    optional(grammarRuleName: string, overrideKind: Nullable<OverrideKind> | undefined, isSkip: boolean | undefined, isLeaf: boolean | undefined, init: (p0: any/* SimpleItemsBuilder */) => void): void;
    list(grammarRuleName: string, min: number, max: number, overrideKind: Nullable<OverrideKind> | undefined, isSkip: boolean | undefined, isLeaf: boolean | undefined, init: (p0: any/* SimpleItemsBuilder */) => void): void;
    separatedList(grammarRuleName: string, min: number, max: number, overrideKind: Nullable<OverrideKind> | undefined, isSkip: boolean | undefined, isLeaf: boolean | undefined, init: (p0: any/* SimpleItemsBuilder */) => void): void;
    preference(itemReference: string, init: (p0: PreferenceRuleBuilder) => void): void;
    build(): Grammar;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarBuilder.$metadata$ {
    const constructor: abstract new () => GrammarBuilder;
}
export declare class GroupChoiceBuilder {
    constructor(localNamespace: Namespace<Grammar>);
    get localNamespace(): Namespace<Grammar>;
    get alternatives(): KtMutableList<RuleItem>;
    alt(init: (p0: any/* ConcatenationItemBuilder */) => void): void;
    build(): Choice;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GroupChoiceBuilder.$metadata$ {
    const constructor: abstract new () => GroupChoiceBuilder;
}
export declare class PreferenceRuleBuilder {
    constructor(grammar: Grammar, forItem: SimpleItem);
    get grammar(): Grammar;
    get forItem(): SimpleItem;
    get optionList(): KtMutableList<PreferenceOption>;
    optionLeft(spine: KtList<string>, choiceIndicator: ChoiceIndicator, choiceNumber: number, terminals: KtList<string>): void;
    optionRight(spine: KtList<string>, choiceIndicator: ChoiceIndicator, choiceNumber: number, terminals: KtList<string>): void;
    build(): PreferenceRule;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PreferenceRuleBuilder.$metadata$ {
    const constructor: abstract new () => PreferenceRuleBuilder;
}
export declare abstract class AglGrammar {
    static readonly getInstance: () => typeof AglGrammar.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglGrammar.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<GrammarDomain, SentenceContext> {
        get OPTION_defaultGoalRule(): string;
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get TYPES_API_NS_QN(): string;
        get TYPES_ASM_NS_QN(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get formatDomain(): AglFormatDomain;
        get styleDomain(): AglStyleDomain;
        get formatStr(): string;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): SyntaxAnalyser<GrammarDomain>;
        get semanticAnalyser(): SemanticAnalyser<GrammarDomain, SentenceContext>;
        get completionProvider(): CompletionProvider<GrammarDomain, SentenceContext>;
        toString(): string;
        private constructor();
    }
}
export declare class AglGrammarCompletionProvider extends CompletionProviderAbstract.$metadata$.constructor<GrammarDomain, SentenceContext> {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglGrammarCompletionProvider.$metadata$ {
    const constructor: abstract new () => AglGrammarCompletionProvider;
}
export declare class AglGrammarSemanticAnalyser implements SemanticAnalyser<GrammarDomain, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: GrammarDomain, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<GrammarDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglGrammarSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => AglGrammarSemanticAnalyser;
}
export declare namespace AglGrammarSemanticAnalyser {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get OPTIONS_KEY_AMBIGUITY_ANALYSIS(): string;
            findGrammarOrNull(sentenceContext: SentenceContext, localNamespace: QualifiedName, grammarNameOrQName: PossiblyQualifiedName): Nullable<Grammar>;
            private constructor();
        }
    }
}
export declare function findTypeForRule(_this_: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, ruleName: GrammarRuleName): Nullable<TypeInstance>;
export declare function contextFromGrammar(grammarDomains: Array<GrammarDomain>): SentenceContext;
export declare class GrammarTypesNamespaceSimple extends GrammarTypesNamespaceAbstract.$metadata$.constructor {
    constructor(qualifiedName: QualifiedName, options: OptionHolder | undefined, _import: KtList<Import>);
    get qualifiedName(): QualifiedName;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
    findTypeForRule(ruleName: GrammarRuleName, excludingImports?: KtSet<Import>): Nullable<TypeInstance>;
    createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarTypesNamespaceSimple.$metadata$ {
    const constructor: abstract new () => GrammarTypesNamespaceSimple;
}
export declare namespace GrammarTypesNamespaceSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            findOrCreateGrammarNamespace(typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, qualifiedName: QualifiedName): GrammarTypesNamespaceSimple;
            private constructor();
        }
    }
}
export declare abstract class GrammarTypesNamespaceAbstract extends TypesNamespaceAbstract.$metadata$.constructor implements GrammarTypesNamespace {
    constructor(options: OptionHolder, _import: KtList<Import>);
    setTypeForGrammarRule(grammarRuleName: GrammarRuleName, typeUse: TypeInstance): void;
    get allRuleNameToType(): KtMutableMap<GrammarRuleName, TypeInstance>;
    set allRuleNameToType(value: KtMutableMap<GrammarRuleName, TypeInstance>);
    get allTypesByRuleName(): any/* Collection<Pair<GrammarRuleName, TypeInstance>> */;
    findTypeForRule(ruleName: GrammarRuleName, excludingImports?: KtSet<Import>): Nullable<TypeInstance>;
    createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
    abstract get qualifiedName(): QualifiedName;
    readonly __doNotUseOrImplementIt: TypesNamespaceAbstract["__doNotUseOrImplementIt"] & GrammarTypesNamespace["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GrammarTypesNamespaceAbstract.$metadata$ {
    const constructor: abstract new () => GrammarTypesNamespaceAbstract;
}
export declare function grammarTypeNamespace(_this_: TypeDomainBuilder, namespaceQualifiedName: string, imports: KtList<string> | undefined, resolveImports: boolean | undefined, init: (p0: any/* GrammarTypeNamespaceBuilder */) => void): void;
/** @deprecated does not allow namespaces */
export declare function grammarTypeModel(namespaceQualifiedName: string, modelName: string, imports: KtList<TypesNamespace> | undefined, init: (p0: any/* GrammarTypeNamespaceBuilder */) => void): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
export declare interface GrammarTypesNamespace extends TypesNamespace {
    readonly allRuleNameToType: KtMap<GrammarRuleName, TypeInstance>;
    readonly allTypesByRuleName: any/* Collection<Pair<GrammarRuleName, TypeInstance>> */;
    findTypeForRule(ruleName: GrammarRuleName, excludingImports?: KtSet<Import>): Nullable<TypeInstance>;
    setTypeForGrammarRule(grammarRuleName: GrammarRuleName, typeUse: TypeInstance): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.grammarTypemodel.api.GrammarTypesNamespace": unique symbol;
    } & TypesNamespace["__doNotUseOrImplementIt"];
}
export declare interface M2mTransformDomain extends Domain<M2mTransformNamespace, M2mTransformRuleSet> {
    readonly namespace: KtList<M2mTransformNamespace>;
    readonly allTransformRuleSet: KtList<M2mTransformRuleSet>;
    readonly allTransformTest: KtList<M2mTransformTest>;
    findOrCreateNamespace(qualifiedName: QualifiedName, imports: KtList<Import>): M2mTransformNamespace;
    findTestDefinitionByQualifiedNameOrNull(qualifiedName: QualifiedName): Nullable<M2mTransformTest>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformDomain": unique symbol;
    } & Domain<M2mTransformNamespace, M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface M2mTransformNamespace extends Namespace<M2mTransformRuleSet> {
    readonly testDefinition: KtList<M2mTransformTest>;
    readonly testDefinitionByName: KtMap<SimpleName, M2mTransformTest>;
    createOwnedTransformRuleSet(name: SimpleName, _extends: KtList<M2MTransformDefinition>, options: OptionHolder): M2mTransformRuleSet;
    findOwnedTestDefinitionOrNull(simpleName: SimpleName): Nullable<M2mTransformTest>;
    addTestDefinition(value: M2mTransformTest): void;
    merge(value: Namespace<M2mTransformRuleSet>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformNamespace": unique symbol;
    } & Namespace<M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface M2MTransformDefinition extends Definition<M2mTransformRuleSet> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2MTransformDefinition": unique symbol;
    } & Definition<M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare interface M2mTransformRuleSetReference extends DefinitionReference<M2mTransformRuleSet> {
    resolveAs(resolved: M2mTransformRuleSet): void;
    cloneTo(ns: M2mTransformNamespace): M2mTransformRuleSetReference;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformRuleSetReference": unique symbol;
    } & DefinitionReference<M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
export declare class DomainReference {
    constructor(value: string);
    get value(): string;
    copy(value?: string): DomainReference;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DomainReference.$metadata$ {
    const constructor: abstract new () => DomainReference;
}
export declare interface M2mTransformRuleSet extends M2MTransformDefinition {
    readonly namespace: M2mTransformNamespace;
    readonly domainParameters: KtMap<DomainReference, SimpleName>;
    readonly domainParameterResolved: KtMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>;
    readonly extends: KtList<M2mTransformRuleSetReference>;
    readonly importTypes: KtList<Import>;
    readonly topRule: KtList<M2mTransformRule>;
    readonly rule: KtMap<SimpleName, M2mTransformRule>;
    addImportType(value: Import): void;
    setRule(rule: M2mTransformRule): void;
    resolveDomainParameter(ref: DomainReference, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): void;
    merge(value: M2mTransformRuleSet): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformRuleSet": unique symbol;
    } & M2MTransformDefinition["__doNotUseOrImplementIt"];
}
export declare interface M2mTransformRuleReference {
    readonly nameOrQName: PossiblyQualifiedName;
    resolved: Nullable<M2mTransformRule>;
    resolveAs(resolved: M2mTransformRule): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformRuleReference": unique symbol;
    };
}
export declare interface M2mTransformRule {
    readonly isTop: boolean;
    readonly name: SimpleName;
    readonly parameters: KtList<VariableDefinition>;
    readonly extends: KtList<M2mTransformRuleReference>;
    readonly domainSignature: KtMap<DomainReference, DomainSignature>;
    conformsTo(other: M2mTransformRule): boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformRule": unique symbol;
    };
}
export declare interface DomainSignature {
    readonly domainRef: DomainReference;
    readonly variable: VariableDefinition;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.DomainSignature": unique symbol;
    };
}
export declare interface VariableDefinition {
    readonly name: SimpleName;
    readonly typeRef: TypeReference;
    readonly type: TypeInstance;
    resolveType(tm: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.VariableDefinition": unique symbol;
    };
}
export declare interface M2mTransformAbstractRule extends M2mTransformRule {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformAbstractRule": unique symbol;
    } & M2mTransformRule["__doNotUseOrImplementIt"];
}
export declare interface M2mTransformPatternRule extends M2mTransformRule {
    readonly pivot: KtMap<SimpleName, VariableDefinition>;
    readonly domainTemplate: KtMap<DomainReference, PropertyTemplateRhs>;
    readonly when_: Nullable<Expression>;
    readonly where: KtList<RuleWhere>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformPatternRule": unique symbol;
    } & M2mTransformRule["__doNotUseOrImplementIt"];
}
export declare interface RuleCall {
    readonly ruleName: SimpleName;
    readonly ruleArguments: KtMap<SimpleName, Expression>;
    readonly domainArguments: KtMap<DomainReference, Expression>;
    resolved: Nullable<M2mTransformRule>;
    resolveAs(resolved: M2mTransformRule): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleCall": unique symbol;
    };
}
export declare interface RuleWhen extends Expression, RuleCall {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhen": unique symbol;
    } & Expression["__doNotUseOrImplementIt"] & RuleCall["__doNotUseOrImplementIt"];
}
export declare interface RuleWhenRelationHolds extends RuleWhen {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhenRelationHolds": unique symbol;
    } & RuleWhen["__doNotUseOrImplementIt"];
}
export declare interface RuleWhenRelationHoldsForAll extends RuleWhen {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhenRelationHoldsForAll": unique symbol;
    } & RuleWhen["__doNotUseOrImplementIt"];
}
export declare interface RuleWhenMappingHolds extends RuleWhen {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhenMappingHolds": unique symbol;
    } & RuleWhen["__doNotUseOrImplementIt"];
}
export declare interface RuleWhenMappingHoldsForAll extends RuleWhen {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhenMappingHoldsForAll": unique symbol;
    } & RuleWhen["__doNotUseOrImplementIt"];
}
export declare interface RuleWhere extends RuleCall {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhere": unique symbol;
    } & RuleCall["__doNotUseOrImplementIt"];
}
export declare interface RuleWhereCallRelation extends RuleWhere {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhereCallRelation": unique symbol;
    } & RuleWhere["__doNotUseOrImplementIt"];
}
export declare interface RuleWhereCallRelationForAll extends RuleWhere {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhereCallRelationForAll": unique symbol;
    } & RuleWhere["__doNotUseOrImplementIt"];
}
export declare interface RuleWhereCallMapping extends RuleWhere {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhereCallMapping": unique symbol;
    } & RuleWhere["__doNotUseOrImplementIt"];
}
export declare interface RuleWhereCallMappingForAll extends RuleWhere {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.RuleWhereCallMappingForAll": unique symbol;
    } & RuleWhere["__doNotUseOrImplementIt"];
}
export declare interface M2MTransformRelation extends M2mTransformPatternRule {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2MTransformRelation": unique symbol;
    } & M2mTransformPatternRule["__doNotUseOrImplementIt"];
}
export declare interface M2MTransformMapping extends M2mTransformPatternRule {
    readonly expression: KtMap<DomainReference, Nullable<Expression>>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2MTransformMapping": unique symbol;
    } & M2mTransformPatternRule["__doNotUseOrImplementIt"];
}
export declare interface M2MTransformTable extends M2mTransformRule {
    readonly values: KtList<KtMap<DomainReference, Expression>>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2MTransformTable": unique symbol;
    } & M2mTransformRule["__doNotUseOrImplementIt"];
}
export declare interface PropertyTemplateRhs {
    readonly identifier: Nullable<SimpleName>;
    setIdentifierValue(value: SimpleName): void;
    resolveTypes(tm: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): KtList<LanguageIssue>;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.PropertyTemplateRhs": unique symbol;
    };
}
export declare interface ObjectTemplate extends PropertyTemplateRhs {
    readonly type: TypeInstance;
    readonly propertyTemplate: KtMap<SimpleName, PropertyTemplate>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.ObjectTemplate": unique symbol;
    } & PropertyTemplateRhs["__doNotUseOrImplementIt"];
}
export declare interface CollectionTemplate extends PropertyTemplateRhs {
    readonly isSubset: boolean;
    readonly elements: KtList<PropertyTemplateRhs>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.CollectionTemplate": unique symbol;
    } & PropertyTemplateRhs["__doNotUseOrImplementIt"];
}
export declare interface PropertyTemplate {
    readonly propertyName: SimpleName;
    readonly rhs: PropertyTemplateRhs;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.PropertyTemplate": unique symbol;
    };
}
export declare interface PropertyTemplateExpression extends PropertyTemplateRhs {
    readonly expression: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.PropertyTemplateExpression": unique symbol;
    } & PropertyTemplateRhs["__doNotUseOrImplementIt"];
}
export declare interface M2mTransformTest {
    readonly namespace: M2mTransformNamespace;
    readonly name: SimpleName;
    readonly qualifiedName: QualifiedName;
    readonly options: OptionHolder;
    readonly domainParameters: KtMap<DomainReference, SimpleName>;
    readonly testCase: KtMap<SimpleName, M2mTransformTestCase>;
    merge(value: M2mTransformTest): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformTest": unique symbol;
    };
}
export declare interface M2mTransformTestCase {
    readonly name: SimpleName;
    readonly domain: KtMap<DomainReference, Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.m2mTransform.api.M2mTransformTestCase": unique symbol;
    };
}
export declare class M2mTransformDomainDefault extends DomainAbstract.$metadata$.constructor<M2mTransformNamespace, M2mTransformRuleSet> implements M2mTransformDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespace?: KtList<M2mTransformNamespace>);
    get name(): SimpleName;
    get allTransformRuleSet(): KtList<M2mTransformRuleSet>;
    get allTransformTest(): KtList<M2mTransformTest>;
    findOrCreateNamespace(qualifiedName: QualifiedName, imports: KtList<Import>): M2mTransformNamespace;
    findTestDefinitionByQualifiedNameOrNull(qualifiedName: QualifiedName): Nullable<M2mTransformTest>;
    get namespace(): KtList<M2mTransformNamespace>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: M2mTransformDomain["__doNotUseOrImplementIt"] & DomainAbstract<M2mTransformNamespace, M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformDomainDefault.$metadata$ {
    const constructor: abstract new () => M2mTransformDomainDefault;
}
export declare class M2mTransformNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<M2mTransformRuleSet> implements M2mTransformNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    get testDefinition(): KtList<M2mTransformTest>;
    get testDefinitionByName(): KtMap<SimpleName, M2mTransformTest>;
    protected get _testDefinition(): (KtMap<SimpleName, M2mTransformTest> & KtMutableMap<SimpleName, M2mTransformTest>)/* LinkedHashMap<SimpleName, M2mTransformTest> */;
    createOwnedTransformRuleSet(name: SimpleName, _extends: KtList<M2MTransformDefinition>, options: OptionHolder): M2mTransformRuleSet;
    findOwnedTestDefinitionOrNull(simpleName: SimpleName): Nullable<M2mTransformTest>;
    addTestDefinition(value: M2mTransformTest): void;
    merge(value: Namespace<M2mTransformRuleSet>): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: M2mTransformNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformNamespaceDefault.$metadata$ {
    const constructor: abstract new () => M2mTransformNamespaceDefault;
}
export declare class M2mTransformRuleSetReferenceDefault implements M2mTransformRuleSetReference {
    constructor(localNamespace: M2mTransformNamespace, nameOrQName: PossiblyQualifiedName);
    get localNamespace(): M2mTransformNamespace;
    get nameOrQName(): PossiblyQualifiedName;
    get resolved(): Nullable<M2mTransformRuleSet>;
    set resolved(value: Nullable<M2mTransformRuleSet>);
    resolveAs(resolved: M2mTransformRuleSet): void;
    cloneTo(ns: M2mTransformNamespace): M2mTransformRuleSetReference;
    copy(localNamespace?: M2mTransformNamespace, nameOrQName?: PossiblyQualifiedName): M2mTransformRuleSetReferenceDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2mTransformRuleSetReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformRuleSetReferenceDefault.$metadata$ {
    const constructor: abstract new () => M2mTransformRuleSetReferenceDefault;
}
export declare class M2mTransformRuleSetDefault extends DefinitionAbstract.$metadata$.constructor<M2mTransformRuleSet> implements M2mTransformRuleSet {
    constructor(namespace: M2mTransformNamespace, name: SimpleName, domainParameters: KtMap<DomainReference, SimpleName>, argExtends: KtList<M2mTransformRuleSetReference> | undefined, options: OptionHolder | undefined, _rules: KtList<M2mTransformRule>);
    get namespace(): M2mTransformNamespace;
    get name(): SimpleName;
    get domainParameters(): KtMap<DomainReference, SimpleName>;
    get options(): OptionHolder;
    get extends(): KtList<M2mTransformRuleSetReference>;
    get importTypes(): KtList<Import>;
    get topRule(): KtList<M2mTransformRule>;
    get rule(): KtMap<SimpleName, M2mTransformRule>;
    get domainParameterResolved(): KtMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>;
    addImportType(value: Import): void;
    setRule(rule: M2mTransformRule): void;
    resolveDomainParameter(ref: DomainReference, typesDomain: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): void;
    merge(value: M2mTransformRuleSet): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: M2mTransformRuleSet["__doNotUseOrImplementIt"] & DefinitionAbstract<M2mTransformRuleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformRuleSetDefault.$metadata$ {
    const constructor: abstract new () => M2mTransformRuleSetDefault;
}
export declare class M2mTransformRuleReferenceDefault implements M2mTransformRuleReference {
    constructor(nameOrQName: PossiblyQualifiedName);
    get nameOrQName(): PossiblyQualifiedName;
    get resolved(): Nullable<M2mTransformRule>;
    set resolved(value: Nullable<M2mTransformRule>);
    resolveAs(resolved: M2mTransformRule): void;
    copy(nameOrQName?: PossiblyQualifiedName): M2mTransformRuleReferenceDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2mTransformRuleReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformRuleReferenceDefault.$metadata$ {
    const constructor: abstract new () => M2mTransformRuleReferenceDefault;
}
export declare abstract class M2mTransformRuleAbstract implements M2mTransformRule {
    constructor();
    get parameters(): KtList<VariableDefinition>;
    get extends(): KtList<M2mTransformRuleReference>;
    conformsTo(other: M2mTransformRule): boolean;
    abstract get isTop(): boolean;
    abstract get name(): SimpleName;
    abstract get domainSignature(): KtMap<DomainReference, DomainSignature>;
    readonly __doNotUseOrImplementIt: M2mTransformRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformRuleAbstract.$metadata$ {
    const constructor: abstract new () => M2mTransformRuleAbstract;
}
export declare class M2MTransformAbstractRuleDefault extends M2mTransformRuleAbstract.$metadata$.constructor implements M2mTransformAbstractRule {
    constructor(isTop: boolean, name: SimpleName);
    get isTop(): boolean;
    get name(): SimpleName;
    get domainSignature(): KtMap<DomainReference, DomainSignature>;
    copy(isTop?: boolean, name?: SimpleName): M2MTransformAbstractRuleDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2mTransformAbstractRule["__doNotUseOrImplementIt"] & M2mTransformRuleAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformAbstractRuleDefault.$metadata$ {
    const constructor: abstract new () => M2MTransformAbstractRuleDefault;
}
export declare class M2MTransformRelationDefault extends M2mTransformRuleAbstract.$metadata$.constructor implements M2MTransformRelation {
    constructor(isTop: boolean, name: SimpleName);
    get isTop(): boolean;
    get name(): SimpleName;
    get domainSignature(): KtMap<DomainReference, DomainSignature>;
    get pivot(): KtMap<SimpleName, VariableDefinition>;
    get domainTemplate(): KtMap<DomainReference, ObjectTemplate>;
    get when_(): Nullable<Expression>;
    set when_(value: Nullable<Expression>);
    get where(): KtMutableList<RuleWhere>;
    copy(isTop?: boolean, name?: SimpleName): M2MTransformRelationDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2MTransformRelation["__doNotUseOrImplementIt"] & M2mTransformRuleAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformRelationDefault.$metadata$ {
    const constructor: abstract new () => M2MTransformRelationDefault;
}
export declare class M2MTransformMappingDefault extends M2mTransformRuleAbstract.$metadata$.constructor implements M2MTransformMapping {
    constructor(isTop: boolean, name: SimpleName);
    get isTop(): boolean;
    get name(): SimpleName;
    get domainSignature(): KtMap<DomainReference, DomainSignature>;
    get pivot(): KtMap<SimpleName, VariableDefinition>;
    get domainTemplate(): KtMap<DomainReference, ObjectTemplate>;
    get expression(): KtMap<DomainReference, Nullable<Expression>>;
    get when_(): Nullable<Expression>;
    set when_(value: Nullable<Expression>);
    get where(): KtMutableList<RuleWhere>;
    copy(isTop?: boolean, name?: SimpleName): M2MTransformMappingDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2MTransformMapping["__doNotUseOrImplementIt"] & M2mTransformRuleAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformMappingDefault.$metadata$ {
    const constructor: abstract new () => M2MTransformMappingDefault;
}
export declare class M2MTransformTableDefault extends M2mTransformRuleAbstract.$metadata$.constructor implements M2MTransformTable {
    constructor(isTop: boolean, name: SimpleName);
    get isTop(): boolean;
    get name(): SimpleName;
    get domainSignature(): KtMap<DomainReference, DomainSignature>;
    get values(): KtList<KtMap<DomainReference, Expression>>;
    copy(isTop?: boolean, name?: SimpleName): M2MTransformTableDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2MTransformTable["__doNotUseOrImplementIt"] & M2mTransformRuleAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformTableDefault.$metadata$ {
    const constructor: abstract new () => M2MTransformTableDefault;
}
export declare class DomainSignatureDefault implements DomainSignature {
    constructor(domainRef: DomainReference, variable: VariableDefinition);
    get domainRef(): DomainReference;
    get variable(): VariableDefinition;
    copy(domainRef?: DomainReference, variable?: VariableDefinition): DomainSignatureDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: DomainSignature["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DomainSignatureDefault.$metadata$ {
    const constructor: abstract new () => DomainSignatureDefault;
}
export declare class VariableDefinitionDefault implements VariableDefinition {
    constructor(name: SimpleName, typeRef: TypeReference);
    get name(): SimpleName;
    get typeRef(): TypeReference;
    get type(): TypeInstance;
    resolveType(tm: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): void;
    copy(name?: SimpleName, typeRef?: TypeReference): VariableDefinitionDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: VariableDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace VariableDefinitionDefault.$metadata$ {
    const constructor: abstract new () => VariableDefinitionDefault;
}
export declare abstract class RuleCallAbstract implements RuleCall {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    get ruleName(): SimpleName;
    get ruleArguments(): KtMap<SimpleName, Expression>;
    get domainArguments(): KtMap<DomainReference, Expression>;
    get resolved(): Nullable<M2mTransformRule>;
    set resolved(value: Nullable<M2mTransformRule>);
    resolveAs(resolved: M2mTransformRule): void;
    readonly __doNotUseOrImplementIt: RuleCall["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleCallAbstract.$metadata$ {
    const constructor: abstract new () => RuleCallAbstract;
}
export declare class RuleWhenRelationHoldsDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhenRelationHolds, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhenRelationHolds["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhenRelationHoldsDefault.$metadata$ {
    const constructor: abstract new () => RuleWhenRelationHoldsDefault;
}
export declare class RuleWhenRelationHoldsForAllDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhenRelationHoldsForAll, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhenRelationHoldsForAll["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhenRelationHoldsForAllDefault.$metadata$ {
    const constructor: abstract new () => RuleWhenRelationHoldsForAllDefault;
}
export declare class RuleWhenMappingHoldsDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhenMappingHolds, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhenMappingHolds["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhenMappingHoldsDefault.$metadata$ {
    const constructor: abstract new () => RuleWhenMappingHoldsDefault;
}
export declare class RuleWhenMappingHoldsForAllDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhenMappingHoldsForAll, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhenMappingHoldsForAll["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhenMappingHoldsForAllDefault.$metadata$ {
    const constructor: abstract new () => RuleWhenMappingHoldsForAllDefault;
}
export declare class RuleWhereCallRelationDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhereCallRelation, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    get ruleName(): SimpleName;
    get ruleArguments(): KtMap<SimpleName, Expression>;
    get domainArguments(): KtMap<DomainReference, Expression>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhereCallRelation["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhereCallRelationDefault.$metadata$ {
    const constructor: abstract new () => RuleWhereCallRelationDefault;
}
export declare class RuleWhereCallRelationForAllDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhereCallRelationForAll, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhereCallRelationForAll["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhereCallRelationForAllDefault.$metadata$ {
    const constructor: abstract new () => RuleWhereCallRelationForAllDefault;
}
export declare class RuleWhereCallMappingDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhereCallMapping, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhereCallMapping["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhereCallMappingDefault.$metadata$ {
    const constructor: abstract new () => RuleWhereCallMappingDefault;
}
export declare class RuleWhereCallMappingForAllDefault extends RuleCallAbstract.$metadata$.constructor implements RuleWhereCallMappingForAll, Expression {
    constructor(ruleName: SimpleName, ruleArguments: KtMap<SimpleName, Expression>, domainArguments: KtMap<DomainReference, Expression>);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    toString(): string;
    readonly __doNotUseOrImplementIt: RuleWhereCallMappingForAll["__doNotUseOrImplementIt"] & Expression["__doNotUseOrImplementIt"] & RuleCallAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace RuleWhereCallMappingForAllDefault.$metadata$ {
    const constructor: abstract new () => RuleWhereCallMappingForAllDefault;
}
export declare class ObjectTemplateDefault implements ObjectTemplate {
    constructor(typeRef: TypeReference, propertyTemplate: KtMap<SimpleName, PropertyTemplate>);
    get typeRef(): TypeReference;
    get propertyTemplate(): KtMap<SimpleName, PropertyTemplate>;
    static new_net_akehurst_language_m2mTransform_asm_ObjectTemplateDefault(type: TypeInstance, propertyTemplate: KtMap<SimpleName, PropertyTemplate>): ObjectTemplateDefault;
    get identifier(): Nullable<SimpleName>;
    set identifier(value: Nullable<SimpleName>);
    get type(): TypeInstance;
    setIdentifierValue(value: SimpleName): void;
    resolveTypes(tm: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): KtList<LanguageIssue>;
    asString(indent?: Indent): string;
    copy(typeRef?: TypeReference, propertyTemplate?: KtMap<SimpleName, PropertyTemplate>): ObjectTemplateDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ObjectTemplate["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ObjectTemplateDefault.$metadata$ {
    const constructor: abstract new () => ObjectTemplateDefault;
}
export declare class CollectionTemplateDefault implements CollectionTemplate {
    constructor(isSubset: boolean, elements: KtList<PropertyTemplateRhs>);
    get isSubset(): boolean;
    get elements(): KtList<PropertyTemplateRhs>;
    get identifier(): Nullable<SimpleName>;
    set identifier(value: Nullable<SimpleName>);
    setIdentifierValue(value: SimpleName): void;
    resolveTypes(tm: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): KtList<LanguageIssue>;
    asString(indent?: Indent): string;
    copy(isSubset?: boolean, elements?: KtList<PropertyTemplateRhs>): CollectionTemplateDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: CollectionTemplate["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CollectionTemplateDefault.$metadata$ {
    const constructor: abstract new () => CollectionTemplateDefault;
}
export declare class PropertyTemplateDefault implements PropertyTemplate {
    constructor(propertyName: SimpleName, rhs: PropertyTemplateRhs);
    get propertyName(): SimpleName;
    get rhs(): PropertyTemplateRhs;
    copy(propertyName?: SimpleName, rhs?: PropertyTemplateRhs): PropertyTemplateDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PropertyTemplate["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyTemplateDefault.$metadata$ {
    const constructor: abstract new () => PropertyTemplateDefault;
}
export declare class PropertyTemplateExpressionDefault implements PropertyTemplateExpression {
    constructor(expression: Expression);
    get expression(): Expression;
    get identifier(): Nullable<SimpleName>;
    set identifier(value: Nullable<SimpleName>);
    setIdentifierValue(value: SimpleName): void;
    resolveTypes(tm: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): KtList<LanguageIssue>;
    asString(indent?: Indent): string;
    readonly __doNotUseOrImplementIt: PropertyTemplateExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyTemplateExpressionDefault.$metadata$ {
    const constructor: abstract new () => PropertyTemplateExpressionDefault;
}
export declare class M2MTransformTestDefault implements M2mTransformTest {
    constructor(namespace: M2mTransformNamespace, name: SimpleName, domainParameters: KtMap<DomainReference, SimpleName>, options?: OptionHolder);
    get namespace(): M2mTransformNamespace;
    get name(): SimpleName;
    get domainParameters(): KtMap<DomainReference, SimpleName>;
    get options(): OptionHolder;
    get qualifiedName(): QualifiedName;
    get testCase(): KtMutableMap<SimpleName, M2mTransformTestCase>;
    merge(value: M2mTransformTest): void;
    copy(namespace?: M2mTransformNamespace, name?: SimpleName, domainParameters?: KtMap<DomainReference, SimpleName>, options?: OptionHolder): M2MTransformTestDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2mTransformTest["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformTestDefault.$metadata$ {
    const constructor: abstract new () => M2MTransformTestDefault;
}
export declare class M2mTransformTestCaseDefault implements M2mTransformTestCase {
    constructor(name: SimpleName);
    get name(): SimpleName;
    get domain(): KtMutableMap<DomainReference, Expression>;
    copy(name?: SimpleName): M2mTransformTestCaseDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: M2mTransformTestCase["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformTestCaseDefault.$metadata$ {
    const constructor: abstract new () => M2mTransformTestCaseDefault;
}
export declare abstract class M2mTransform {
    static readonly getInstance: () => typeof M2mTransform.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransform.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<M2mTransformDomain, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get goalRuleName(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get formatDomain(): AglFormatDomain;
        get styleDomain(): AglStyleDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): SyntaxAnalyser<M2mTransformDomain>;
        get semanticAnalyser(): SemanticAnalyser<M2mTransformDomain, SentenceContext>;
        get completionProvider(): CompletionProvider<M2mTransformDomain, SentenceContext>;
        toString(): string;
        private constructor();
    }
}
export declare class M2mTransformCompletionProvider extends CompletionProviderAbstract.$metadata$.constructor<M2mTransformDomain, SentenceContext> {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformCompletionProvider.$metadata$ {
    const constructor: abstract new () => M2mTransformCompletionProvider;
}
export declare class M2MTransformResult {
    constructor(issues: IssueHolder, record: KtMap<M2mTransformRule, MappingRecord>, targetDomainRef: DomainReference);
    get issues(): IssueHolder;
    get record(): KtMap<M2mTransformRule, MappingRecord>;
    get targetDomainRef(): DomainReference;
    get targets(): KtList<TypedObject>;
    asString(indent?: Indent): string;
    copy(issues?: IssueHolder, record?: KtMap<M2mTransformRule, MappingRecord>, targetDomainRef?: DomainReference): M2MTransformResult;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformResult.$metadata$ {
    const constructor: abstract new () => M2MTransformResult;
}
export declare class TemplateMatchAlternatives {
    constructor(alternatives: KtList<TemplateMatchResult>);
    get alternatives(): KtList<TemplateMatchResult>;
    get isMatch(): boolean;
    merge(): TemplateMatchResult;
    withVariable(name: string, value: TypedObject): TemplateMatchAlternatives;
    copy(alternatives?: KtList<TemplateMatchResult>): TemplateMatchAlternatives;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateMatchAlternatives.$metadata$ {
    const constructor: abstract new () => TemplateMatchAlternatives;
}
export declare class TemplateMatchResult {
    constructor(isMatch: boolean, matchedVariables: KtMap<string, TypedObject>);
    get isMatch(): boolean;
    get matchedVariables(): KtMap<string, TypedObject>;
    getValueNamed(name: string): Nullable<TypedObject>;
    withVariable(name: string, value: TypedObject): TemplateMatchResult;
    merge(other: TemplateMatchResult): TemplateMatchResult;
    copy(isMatch?: boolean, matchedVariables?: KtMap<string, TypedObject>): TemplateMatchResult;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TemplateMatchResult.$metadata$ {
    const constructor: abstract new () => TemplateMatchResult;
}
export declare namespace TemplateMatchResult {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            EMPTY(): TemplateMatchResult;
            merge(_this_: any/* Collection<TemplateMatchResult> */): TemplateMatchResult;
            private constructor();
        }
    }
}
export declare class MappingRecord {
    constructor(rule: M2mTransformRule, alternatives: KtList<KtMap<DomainReference, TypedObject>>);
    get rule(): M2mTransformRule;
    get alternatives(): KtList<KtMap<DomainReference, TypedObject>>;
    merge(other: MappingRecord): MappingRecord;
    bySource(source: KtMap<DomainReference, KtList<TypedObject>>): KtList<KtMap<DomainReference, TypedObject>>;
    asString(indent?: Indent): string;
    copy(rule?: M2mTransformRule, alternatives?: KtList<KtMap<DomainReference, TypedObject>>): MappingRecord;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MappingRecord.$metadata$ {
    const constructor: abstract new () => MappingRecord;
}
export declare namespace MappingRecord {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            EMPTY(rule: M2mTransformRule): MappingRecord;
            merge(_this_: any/* Collection<MappingRecord> */, rule: M2mTransformRule): MappingRecord;
            private constructor();
        }
    }
}
export declare class M2mTransformExecutionContext {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformExecutionContext.$metadata$ {
    const constructor: abstract new () => M2mTransformExecutionContext;
}
export declare class M2mTransformInterpreter {
    constructor(m2m: M2mTransformDomain, domainAccessorMutatorByDomainName: KtMap<SimpleName, ObjectGraphAccessorMutator>, issues?: IssueHolder);
    get m2m(): M2mTransformDomain;
    get domainAccessorMutatorByDomainName(): KtMap<SimpleName, ObjectGraphAccessorMutator>;
    get issues(): IssueHolder;
    transform(targetTransform: M2mTransformRuleSet, targetDomainRef: DomainReference, domainGraphs: KtMap<DomainReference, KtList<TypedObject>>): M2MTransformResult;
    matchVariablesFromRhs(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, accessorMutator: ObjectGraphAccessorMutator, src: TypedObject, rhs: PropertyTemplateRhs): TemplateMatchAlternatives;
    matchVariablesFromPropertyTemplateExpression(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, accessorMutator: ObjectGraphAccessorMutator, lhs: TypedObject, rhs: PropertyTemplateExpression): TemplateMatchResult;
    matchVariablesFromObjectTemplate(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, objectTemplate: ObjectTemplate, accessorMutator: ObjectGraphAccessorMutator, src: TypedObject): TemplateMatchAlternatives;
    matchVariablesFromCollectionTemplate(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, collectionTemplate: CollectionTemplate, accessorMutator: ObjectGraphAccessorMutator, src: TypedObject): TemplateMatchAlternatives;
    matchVariablesFromCollectionTemplateToElementsIn(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, collectionTemplate: CollectionTemplate, accessorMutator: ObjectGraphAccessorMutator, elements: KtList<TypedObject>): KtList<TemplateMatchResult>;
    executeWhen(m2mExecution: any/* M2mTransformExecution */, owningRule: M2mTransformRule, when_: Expression, evc: EvaluationContext): any/* Pair<boolean, EvaluationContext> */;
    executeWhere(m2mExecution: any/* M2mTransformExecution */, owningRule: M2mTransformRule, where: RuleWhere, evc: EvaluationContext): EvaluationContext;
    executeRuleWhere(m2mExecution: any/* M2mTransformExecution */, owningRule: M2mTransformRule, rule: M2mTransformRule, source: KtMap<DomainReference, KtList<TypedObject>>): Nullable<TypedObject>;
    getSource(m2mExecution: any/* M2mTransformExecution */, rule: M2mTransformRule, arguments: KtMap<DomainReference, Expression>, evc: EvaluationContext): KtMap<DomainReference, KtList<TypedObject>>;
    evaluateArgs(m2mExecution: any/* M2mTransformExecution */, rule: M2mTransformRule, arguments: KtList<Expression>, matchedVariables: KtMap<string, TypedObject>): KtMap<DomainReference, KtList<TypedObject>>;
    createFromRhs(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, lhsType: TypeInstance, rhs: PropertyTemplateRhs): any/* Pair<TypedObject, KtMap<string, TypedObject>> */;
    createFromPropertyTemplateExpression(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, lhsType: TypeInstance, rhs: PropertyTemplateExpression): any/* Pair<TypedObject, KtMap<string, TypedObject>> */;
    createFromExpression(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, lhsType: TypeInstance, expression: Expression): TypedObject;
    createFromObjectTemplate(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, lhsType: TypeInstance, objectTemplate: ObjectTemplate): any/* Pair<TypedObject, KtMap<string, TypedObject>> */;
    createFromCollectionTemplate(m2mExecution: any/* M2mTransformExecution */, evc: EvaluationContext, lhsType: TypeInstance, collectionTemplate: CollectionTemplate): any/* Pair<TypedObject, KtMap<string, TypedObject>> */;
    setPropertiesFromRhs(m2mExecution: any/* M2mTransformExecution */, obj: TypedObject, evc: EvaluationContext, rhs: PropertyTemplateRhs): void;
    setPropertiesFromExpression(m2mExecution: any/* M2mTransformExecution */, obj: TypedObject, evc: EvaluationContext, expression: Expression): void;
    setPropertiesFromObjectTemplate(m2mExecution: any/* M2mTransformExecution */, obj: TypedObject, evc: EvaluationContext, objectTemplate: ObjectTemplate): void;
    setPropertiesFromCollectionTemplate(m2mExecution: any/* M2mTransformExecution */, obj: TypedObject, evc: EvaluationContext, collectionTemplate: CollectionTemplate): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformInterpreter.$metadata$ {
    const constructor: abstract new () => M2mTransformInterpreter;
}
export declare namespace M2mTransformInterpreter {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        namespace type {
            class CoverOption<B, R> {
                constructor(b: B, r: R);
                get b(): B;
                get r(): R;
                copy(b?: B, r?: R): M2mTransformInterpreter.Companion.CoverOption<B, R>;
                toString(): string;
                hashCode(): number;
                equals(other: Nullable<any>): boolean;
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace CoverOption.$metadata$ {
                const constructor: abstract new <B, R>() => CoverOption<B, R>;
            }
        }
        abstract class constructor {
            findCoveringSubsets2<T, B, R>(cover: any/* Collection<T> */, bySubsetsOf: any/* Collection<B> */, matches: (p0: T, p1: B) => any/* Pair<boolean, R> */): KtList<KtList<R>>;
            findCoveringSubsets<T, B, R>(cover: any/* Collection<T> */, bySubsetsOf: any/* Collection<B> */, matches: (p0: T, p1: B) => any/* Pair<boolean, R> */): KtSet<KtList<R>>;
            cartesianProduct<OT extends any>(_this_: KtList<TemplateMatchAlternatives>): TemplateMatchAlternatives;
            cartesianProduct<K, V>(_this_: KtMap<K, KtList<V>>): KtList<KtMap<K, V>>;
            cartesianProduct<E>(_this_: any/* Collection<KtList<E>> */): KtList<KtList<E>>;
            private constructor();
        }
    }
}
export declare class M2mTransformInterpreterSuspending {
    constructor(m2m: M2mTransformDomain, domainObjectGraph: KtMap<SimpleName, ObjectGraphAccessorMutator>, _issues?: IssueHolder);
    get m2m(): M2mTransformDomain;
    get domainObjectGraph(): KtMap<SimpleName, ObjectGraphAccessorMutator>;
    get _issues(): IssueHolder;
    get records(): KtMutableMap<M2mTransformRule, MappingRecord>;
    transform(targetTransform: M2mTransformRuleSet, targetDomainRef: DomainReference, domainGraphs: KtMap<DomainReference, KtList<TypedObject>>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    matchVariablesFromRhs(variables: KtMap<string, TypedObject>, srcObjectGraph: ObjectGraphAccessorMutator, src: TypedObject, rhs: PropertyTemplateRhs, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    matchVariablesFromPropertyTemplateExpression(variables: KtMap<string, TypedObject>, srcObjectGraph: ObjectGraphAccessorMutator, lhs: TypedObject, rhs: PropertyTemplateExpression, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    matchVariablesFromObjectTemplate(variables: KtMap<string, TypedObject>, objectTemplate: ObjectTemplate, srcObjectGraph: ObjectGraphAccessorMutator, src: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    matchVariablesFromCollectionTemplate(variables: KtMap<string, TypedObject>, collectionTemplate: CollectionTemplate, srcObjectGraph: ObjectGraphAccessorMutator, src: TypedObject, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    executeWhere(where: RuleWhere, targetTransform: M2mTransformRuleSet, targetDomainRef: DomainReference, matchedVariables: KtMap<string, TypedObject>, objectGraph: KtMap<DomainReference, ObjectGraphAccessorMutator>, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    createFromRhs(variables: KtMap<string, TypedObject>, rhs: PropertyTemplateRhs, tgtObjectGraph: ObjectGraphAccessorMutator, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    createFromPropertyPatternExpression(variables: KtMap<string, TypedObject>, ppe: PropertyTemplateExpression, tgtObjectGraph: ObjectGraphAccessorMutator, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
    createFromObjectPattern(variables: KtMap<string, TypedObject>, objectTemplate: ObjectTemplate, tgtObjectGraph: ObjectGraphAccessorMutator, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformInterpreterSuspending.$metadata$ {
    const constructor: abstract new () => M2mTransformInterpreterSuspending;
}
export declare namespace M2mTransformInterpreterSuspending {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        namespace type {
            class CoverOption<B, R> {
                constructor(b: B, r: R);
                get b(): B;
                get r(): R;
                copy(b?: B, r?: R): M2mTransformInterpreterSuspending.Companion.CoverOption<B, R>;
                toString(): string;
                hashCode(): number;
                equals(other: Nullable<any>): boolean;
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace CoverOption.$metadata$ {
                const constructor: abstract new <B, R>() => CoverOption<B, R>;
            }
        }
        abstract class constructor {
            findCoveringSubsets2<T, B, R>(cover: any/* Collection<T> */, bySubsetsOf: any/* Collection<B> */, matches: any /*Suspend functions are not supported*/, $completion: any/* Continuation<Nullable<any>> */): Nullable<any>;
            findCoveringSubsets<T, B, R>(cover: any/* Collection<T> */, bySubsetsOf: any/* Collection<B> */, matches: (p0: T, p1: B) => any/* Pair<boolean, R> */): KtSet<KtList<R>>;
            cartesianProduct<OT extends any>(_this_: KtList<TemplateMatchAlternatives>): TemplateMatchAlternatives;
            cartesianProduct<K, V>(_this_: KtMap<K, KtList<V>>): KtList<KtMap<K, V>>;
            cartesianProduct<E>(_this_: any/* Collection<KtList<E>> */): KtList<KtList<E>>;
            private constructor();
        }
    }
}
export declare class M2mTransformSemanticAnalyser implements SemanticAnalyser<M2mTransformDomain, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: M2mTransformDomain, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<M2mTransformDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => M2mTransformSemanticAnalyser;
}
export declare class M2mTransformSyntaxAnalyser extends SyntaxAnalyserByMethodRegistrationAbstract.$metadata$.constructor<M2mTransformDomain> {
    constructor();
    get extendsSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    get embeddedSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    registerHandlers(): void;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mTransformSyntaxAnalyser.$metadata$ {
    const constructor: abstract new () => M2mTransformSyntaxAnalyser;
}
export declare class M2mPatternExecution {
    constructor(description: string, inputs: KtList<string>, outputs: KtList<string>, execution: (p0: EvaluationContext) => void);
    get description(): string;
    get inputs(): KtList<string>;
    get outputs(): KtList<string>;
    get execution(): (p0: EvaluationContext) => void;
    get index(): number;
    set index(value: number);
    get doMeBefore(): KtMutableSet<M2mPatternExecution>;
    get doMeBeforeAll(): KtSet<M2mPatternExecution>;
    mustComeBefore(other: M2mPatternExecution): boolean;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mPatternExecution.$metadata$ {
    const constructor: abstract new () => M2mPatternExecution;
}
export declare class M2mPatternExecutor {
    constructor(issues: IssueHolder, accessorMutator: ObjectGraphAccessorMutator, initialExes: KtList<M2mPatternExecution>);
    get issues(): IssueHolder;
    get accessorMutator(): ObjectGraphAccessorMutator;
    addExecution(value: M2mPatternExecution): void;
    executionPlan(): KtList<M2mPatternExecution>;
    buildAndExecute(tgtName: string, template: PropertyTemplateRhs, lhsType: TypeInstance, evc1: EvaluationContext): void;
    build(tgtName: string, template: PropertyTemplateRhs, lhsType: TypeInstance): void;
    execute(evc1: EvaluationContext, tgtName: string): TypedObject;
    groupedExecutions(inputs: KtList<string>, outputs: KtList<string>, doBeforeMe: KtSet<M2mPatternExecution>, doAfterMe: KtSet<M2mPatternExecution>, content: (p0: M2mPatternExecution, p1: M2mPatternExecution) => KtList<M2mPatternExecution>): M2mPatternExecution;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mPatternExecutor.$metadata$ {
    const constructor: abstract new () => M2mPatternExecutor;
}
export declare namespace M2mPatternExecutor {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get RESULT(): string;
            private constructor();
        }
    }
}
export declare class M2mPatternMatcher {
    constructor(issues: IssueHolder, accessorMutator: ObjectGraphAccessorMutator);
    get issues(): IssueHolder;
    get accessorMutator(): ObjectGraphAccessorMutator;
    matchVariablesFromRhs(variables: KtMap<string, TypedObject>, src: TypedObject, rhs: PropertyTemplateRhs): TemplateMatchAlternatives;
    matchVariablesFromPropertyTemplateExpression(variables: KtMap<string, TypedObject>, template: PropertyTemplateExpression, src: TypedObject): TemplateMatchResult;
    matchVariablesFromObjectTemplate(variables: KtMap<string, TypedObject>, template: ObjectTemplate, src: TypedObject): TemplateMatchAlternatives;
    matchVariablesFromCollectionTemplate(variables: KtMap<string, TypedObject>, template: CollectionTemplate, src: TypedObject): TemplateMatchAlternatives;
    matchVariablesFromCollectionTemplateToElementsIn(variables: KtMap<string, TypedObject>, collectionTemplate: CollectionTemplate, elements: KtList<TypedObject>): KtList<TemplateMatchResult>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2mPatternMatcher.$metadata$ {
    const constructor: abstract new () => M2mPatternMatcher;
}
export declare class TransformTestSuit {
    constructor(description: string);
    get description(): string;
    get typeDomains(): KtMutableMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>;
    get crossReferenceDomains(): KtMutableMap<DomainReference, CrossReferenceDomain>;
    get transform(): string;
    set transform(value: string);
    get testCase(): KtMutableMap<string, TransformTestCase>;
    copy(description?: string): TransformTestSuit;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TransformTestSuit.$metadata$ {
    const constructor: abstract new () => TransformTestSuit;
}
export declare class TransformTestCase {
    constructor(description: string);
    get description(): string;
    get input(): KtMutableMap<DomainReference, Asm>;
    get target(): Nullable<DomainReference>;
    set target(value: Nullable<DomainReference>);
    get expected(): Nullable<Asm>;
    set expected(value: Nullable<Asm>);
    get expectedIssues(): KtSet<LanguageIssue>;
    copy(description?: string): TransformTestCase;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TransformTestCase.$metadata$ {
    const constructor: abstract new () => TransformTestCase;
}
export declare function m2mTransformTestSuits(init: (p0: M2MTransformTestSuitListBuilder) => void): KtMap<string, TransformTestSuit>;
export declare class M2MTransformTestSuitListBuilder {
    constructor();
    testSuit(description: string, init: (p0: M2MTransformTestSuitBuilder) => void): void;
    build(): KtMap<string, TransformTestSuit>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformTestSuitListBuilder.$metadata$ {
    const constructor: abstract new () => M2MTransformTestSuitListBuilder;
}
export declare class M2MTransformTestSuitBuilder {
    constructor(description: string);
    get description(): string;
    typesDomain(domainReference: string, domainName: string, resolveImports: boolean, namespaces: KtList<TypesNamespace> | undefined, init: (p0: TypeDomainBuilder) => void): void;
    crossReferenceDomain(domainReference: string, name: string, init: (p0: CrossReferenceDomainBuilder) => void): void;
    transform(transformString: string): void;
    testCase(description: string, init: (p0: M2MTransformTestCaseBuilder) => void): void;
    build(): TransformTestSuit;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformTestSuitBuilder.$metadata$ {
    const constructor: abstract new () => M2MTransformTestSuitBuilder;
}
export declare class M2MTransformTestCaseBuilder {
    constructor(description: string, typeDomains: KtMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>, crossReferenceDomain: KtMutableMap<DomainReference, CrossReferenceDomain>);
    get description(): string;
    get typeDomains(): KtMap<DomainReference, Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>;
    get crossReferenceDomain(): KtMutableMap<DomainReference, CrossReferenceDomain>;
    input(domainReference: string, defaultNamespace: string | undefined, sentenceId: Nullable<any> | undefined, context: Nullable<SentenceContext> | undefined, resolveReferences: boolean | undefined, failIfIssues: boolean | undefined, resolvedReferences: KtMutableList<ResolvedReference> | undefined, init: (p0: AsmSimpleBuilder) => void): void;
    expectIssue(kind: LanguageIssueKind, message: string, phase?: LanguageProcessorPhase, location?: Nullable<InputLocation>, data?: Nullable<any>): void;
    target(domainReference: string, defaultNamespace: string | undefined, sentenceId: Nullable<any> | undefined, context: Nullable<SentenceContext> | undefined, resolveReferences: boolean | undefined, failIfIssues: boolean | undefined, resolvedReferences: KtMutableList<ResolvedReference> | undefined, init: (p0: AsmSimpleBuilder) => void): void;
    build(): TransformTestCase;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace M2MTransformTestCaseBuilder.$metadata$ {
    const constructor: abstract new () => M2MTransformTestCaseBuilder;
}
export declare abstract class AglCrossReference {
    static readonly getInstance: () => typeof AglCrossReference.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglCrossReference.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<CrossReferenceDomain, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get goalRuleName(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get styleDomain(): AglStyleDomain;
        get formatDomain(): AglFormatDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): ReferencesSyntaxAnalyser;
        get semanticAnalyser(): ReferencesSemanticAnalyser;
        get completionProvider(): ReferencesCompletionProvider;
        get formatterStr(): string;
        private constructor();
    }
}
export declare class ReferencesCompletionProvider extends CompletionProviderAbstract.$metadata$.constructor<CrossReferenceDomain, SentenceContext> {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferencesCompletionProvider.$metadata$ {
    const constructor: abstract new () => ReferencesCompletionProvider;
}
export declare class ReferencesSemanticAnalyser implements SemanticAnalyser<CrossReferenceDomain, SentenceContext> {
    constructor();
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: CrossReferenceDomain, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<CrossReferenceDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferencesSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => ReferencesSemanticAnalyser;
}
export declare class ReferencesSyntaxAnalyser extends SyntaxAnalyserByMethodRegistrationAbstract.$metadata$.constructor<CrossReferenceDomain> {
    constructor();
    registerHandlers(): void;
    get extendsSyntaxAnalyser(): KtMap<QualifiedName, SyntaxAnalyser<any /*UnknownType **/>>;
    clear<T extends any>(done?: KtSet<SyntaxAnalyser<T>>): void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferencesSyntaxAnalyser.$metadata$ {
    const constructor: abstract new () => ReferencesSyntaxAnalyser;
}
export declare namespace ReferencesSyntaxAnalyser {
    class PropertyValue {
        constructor(asmObject: any, value: string);
        get asmObject(): any;
        get value(): string;
        copy(asmObject?: any, value?: string): ReferencesSyntaxAnalyser.PropertyValue;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace PropertyValue.$metadata$ {
        const constructor: abstract new () => PropertyValue;
    }
}
export declare interface CrossReferenceDomain extends Domain<CrossReferenceNamespace, DeclarationsForNamespace> {
    readonly declarationsForNamespace: KtMap<QualifiedName, DeclarationsForNamespace>;
    isScopeDefinedFor(possiblyQualifiedTypeName: PossiblyQualifiedName): boolean;
    referencesFor(possiblyQualifiedTypeName: PossiblyQualifiedName): KtList<ReferenceExpression>;
    referenceForProperty(typeQualifiedName: QualifiedName, propertyName: string): KtList<QualifiedName>;
    identifyingExpressionFor(scopeForTypeName: SimpleName, possiblyQualifiedTypeName: PossiblyQualifiedName): Nullable<Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.CrossReferenceDomain": unique symbol;
    } & Domain<CrossReferenceNamespace, DeclarationsForNamespace>["__doNotUseOrImplementIt"];
}
export declare interface CrossReferenceNamespace extends Namespace<DeclarationsForNamespace> {
    readonly declarationsForNamespace: DeclarationsForNamespace;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.CrossReferenceNamespace": unique symbol;
    } & Namespace<DeclarationsForNamespace>["__doNotUseOrImplementIt"];
}
export declare interface DeclarationsForNamespace extends Definition<DeclarationsForNamespace> {
    readonly importedNamespaces: KtList<Import>;
    readonly scopeDefinition: KtMap<SimpleName, ScopeDefinition>;
    readonly references: KtList<ReferenceDefinition>;
    readonly isEmpty: boolean;
    isScopeDefinedFor(typeName: SimpleName): boolean;
    referencesFor(typeName: SimpleName): KtList<ReferenceExpression>;
    referenceForPropertyOrNull(typeName: SimpleName, propertyName: string): Nullable<ReferenceExpression>;
    identifyingExpressionFor(scopeForTypeName: SimpleName, typeName: SimpleName): Nullable<Expression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.DeclarationsForNamespace": unique symbol;
    } & Definition<DeclarationsForNamespace>["__doNotUseOrImplementIt"];
}
export declare interface ReferenceDefinition extends Formatable {
    readonly inTypeName: SimpleName;
    readonly referenceExpressionList: KtList<ReferenceExpression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.ReferenceDefinition": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface ScopeDefinition extends Formatable {
    readonly scopeForTypeName: SimpleName;
    readonly identifiables: KtList<Identifiable>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.ScopeDefinition": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface Identifiable extends Formatable {
    readonly typeName: SimpleName;
    readonly identifiedBy: Expression;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.Identifiable": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface ReferenceExpression extends Formatable {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.ReferenceExpression": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface ReferenceExpressionProperty extends ReferenceExpression {
    readonly referringPropertyNavigation: NavigationExpression;
    readonly refersToTypeName: KtList<PossiblyQualifiedName>;
    readonly fromNavigation: Nullable<NavigationExpression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.ReferenceExpressionProperty": unique symbol;
    } & ReferenceExpression["__doNotUseOrImplementIt"];
}
export declare interface ReferenceExpressionCollection extends ReferenceExpression {
    readonly expression: Expression;
    readonly ofType: Nullable<PossiblyQualifiedName>;
    readonly referenceExpressionList: KtList<ReferenceExpression>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.reference.api.ReferenceExpressionCollection": unique symbol;
    } & ReferenceExpression["__doNotUseOrImplementIt"];
}
export declare class CrossReferenceDomainDefault extends DomainAbstract.$metadata$.constructor<CrossReferenceNamespace, DeclarationsForNamespace> implements CrossReferenceDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespace?: KtList<CrossReferenceNamespace>);
    get name(): SimpleName;
    get declarationsForNamespace(): KtMap<QualifiedName, DeclarationsForNamespace>;
    get isEmpty(): boolean;
    isScopeDefinedFor(possiblyQualifiedTypeName: PossiblyQualifiedName): boolean;
    referencesFor(possiblyQualifiedTypeName: PossiblyQualifiedName): KtList<ReferenceExpression>;
    identifyingExpressionFor(scopeForTypeName: SimpleName, possiblyQualifiedTypeName: PossiblyQualifiedName): Nullable<Expression>;
    referenceForProperty(typeQualifiedName: QualifiedName, propertyName: string): KtList<QualifiedName>;
    addRecordReferenceForProperty(typeQualifiedName: QualifiedName, propertyName: string, refersToQualifiedTypeNames: KtList<QualifiedName>): void;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: DomainAbstract<CrossReferenceNamespace, DeclarationsForNamespace>["__doNotUseOrImplementIt"] & CrossReferenceDomain["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CrossReferenceDomainDefault.$metadata$ {
    const constructor: abstract new () => CrossReferenceDomainDefault;
}
export declare namespace CrossReferenceDomainDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get ROOT_SCOPE_TYPE_NAME(): QualifiedName;
            get IDENTIFY_BY_NOTHING(): string;
            fromString(context: Nullable<SentenceContext>, crossReferenceString: CrossReferenceString): ProcessResult<CrossReferenceDomain>;
            private constructor();
        }
    }
}
export declare class CrossReferenceNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<DeclarationsForNamespace> implements CrossReferenceNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    get declarationsForNamespace(): DeclarationsForNamespace;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: NamespaceAbstract<DeclarationsForNamespace>["__doNotUseOrImplementIt"] & CrossReferenceNamespace["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CrossReferenceNamespaceDefault.$metadata$ {
    const constructor: abstract new () => CrossReferenceNamespaceDefault;
}
export declare class DeclarationsForNamespaceDefault extends DefinitionAbstract.$metadata$.constructor<DeclarationsForNamespace> implements DeclarationsForNamespace {
    constructor(namespace: CrossReferenceNamespace, options?: OptionHolder);
    get namespace(): CrossReferenceNamespace;
    get options(): OptionHolder;
    get name(): SimpleName;
    get importedNamespaces(): KtList<Import>;
    get scopeDefinition(): KtMutableMap<SimpleName, ScopeDefinition>;
    get references(): KtMutableList<ReferenceDefinition>;
    get isEmpty(): boolean;
    isScopeDefinedFor(typeName: SimpleName): boolean;
    referencesFor(typeName: SimpleName): KtList<ReferenceExpression>;
    referenceForPropertyOrNull(typeName: SimpleName, propertyName: string): Nullable<ReferenceExpression>;
    identifyingExpressionFor(scopeForTypeName: SimpleName, typeName: SimpleName): Nullable<Expression>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(namespace?: CrossReferenceNamespace, options?: OptionHolder): DeclarationsForNamespaceDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: DeclarationsForNamespace["__doNotUseOrImplementIt"] & DefinitionAbstract<DeclarationsForNamespace>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DeclarationsForNamespaceDefault.$metadata$ {
    const constructor: abstract new () => DeclarationsForNamespaceDefault;
}
export declare class ScopeDefinitionDefault implements ScopeDefinition {
    constructor(scopeForTypeName: SimpleName);
    get scopeForTypeName(): SimpleName;
    get identifiables(): KtMutableList<Identifiable>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(scopeForTypeName?: SimpleName): ScopeDefinitionDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ScopeDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScopeDefinitionDefault.$metadata$ {
    const constructor: abstract new () => ScopeDefinitionDefault;
}
export declare class IdentifiableDefault implements Identifiable {
    constructor(typeName: SimpleName, identifiedBy: Expression);
    get typeName(): SimpleName;
    get identifiedBy(): Expression;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(typeName?: SimpleName, identifiedBy?: Expression): IdentifiableDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: Identifiable["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IdentifiableDefault.$metadata$ {
    const constructor: abstract new () => IdentifiableDefault;
}
export declare class ReferenceDefinitionDefault implements ReferenceDefinition {
    constructor(inTypeName: SimpleName, referenceExpressionList: KtList<ReferenceExpression>);
    get inTypeName(): SimpleName;
    get referenceExpressionList(): KtList<ReferenceExpression>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(inTypeName?: SimpleName, referenceExpressionList?: KtList<ReferenceExpression>): ReferenceDefinitionDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ReferenceDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceDefinitionDefault.$metadata$ {
    const constructor: abstract new () => ReferenceDefinitionDefault;
}
export declare abstract class ReferenceExpressionAbstract implements ReferenceExpression {
    constructor();
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: ReferenceExpression["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceExpressionAbstract.$metadata$ {
    const constructor: abstract new () => ReferenceExpressionAbstract;
}
export declare class ReferenceExpressionPropertyDefault extends ReferenceExpressionAbstract.$metadata$.constructor implements ReferenceExpressionProperty {
    constructor(referringPropertyNavigation: NavigationExpression, refersToTypeName: KtList<PossiblyQualifiedName>, fromNavigation: Nullable<NavigationExpression>);
    get referringPropertyNavigation(): NavigationExpression;
    get refersToTypeName(): KtList<PossiblyQualifiedName>;
    get fromNavigation(): Nullable<NavigationExpression>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(referringPropertyNavigation?: NavigationExpression, refersToTypeName?: KtList<PossiblyQualifiedName>, fromNavigation?: Nullable<NavigationExpression>): ReferenceExpressionPropertyDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ReferenceExpressionAbstract["__doNotUseOrImplementIt"] & ReferenceExpressionProperty["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceExpressionPropertyDefault.$metadata$ {
    const constructor: abstract new () => ReferenceExpressionPropertyDefault;
}
export declare class ReferenceExpressionCollectionDefault extends ReferenceExpressionAbstract.$metadata$.constructor implements ReferenceExpressionCollection {
    constructor(expression: Expression, ofType: Nullable<PossiblyQualifiedName>, referenceExpressionList: KtList<ReferenceExpressionAbstract>);
    get expression(): Expression;
    get ofType(): Nullable<PossiblyQualifiedName>;
    get referenceExpressionList(): KtList<ReferenceExpressionAbstract>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(expression?: Expression, ofType?: Nullable<PossiblyQualifiedName>, referenceExpressionList?: KtList<ReferenceExpressionAbstract>): ReferenceExpressionCollectionDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: ReferenceExpressionAbstract["__doNotUseOrImplementIt"] & ReferenceExpressionCollection["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceExpressionCollectionDefault.$metadata$ {
    const constructor: abstract new () => ReferenceExpressionCollectionDefault;
}
export declare function crossReferenceDomain(name: string, init: (p0: CrossReferenceDomainBuilder) => void): CrossReferenceDomain;
export declare class CrossReferenceDomainBuilder {
    constructor(_name: string);
    declarationsFor(namespaceQualifiedName: string, init: (p0: DeclarationsForNamespaceBuilder) => void): void;
    build(): CrossReferenceDomain;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CrossReferenceDomainBuilder.$metadata$ {
    const constructor: abstract new () => CrossReferenceDomainBuilder;
}
export declare class DeclarationsForNamespaceBuilder {
    constructor(namespace: CrossReferenceNamespace);
    import(namespaceQualifiedName: string): void;
    identify(typeName: string, expressionStr: string): void;
    scope(forTypeName: string, init: (p0: ScopeDefinitionBuilder) => void): void;
    reference(inType: string, init: (p0: ReferenceDefinitionBuilder) => void): void;
    build(): any/* Pair<DeclarationsForNamespace, KtList<Import>> */;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DeclarationsForNamespaceBuilder.$metadata$ {
    const constructor: abstract new () => DeclarationsForNamespaceBuilder;
}
export declare class ScopeDefinitionBuilder {
    constructor(_forTypeName: SimpleName);
    identify(typeName: string, expressionStr: string): void;
    build(): ScopeDefinition;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScopeDefinitionBuilder.$metadata$ {
    const constructor: abstract new () => ScopeDefinitionBuilder;
}
export declare class ReferenceDefinitionBuilder {
    constructor(_inType: SimpleName);
    get _refExpressionList(): KtMutableList<ReferenceExpression>;
    property(referringPropertyStr: string, refersToTypes: KtList<string>, fromExpressionStr: Nullable<string>): void;
    collection(): void;
    build(): ReferenceDefinition;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ReferenceDefinitionBuilder.$metadata$ {
    const constructor: abstract new () => ReferenceDefinitionBuilder;
}
export declare abstract class AglRegex {
    static readonly getInstance: () => typeof AglRegex.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglRegex.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<Regex, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<LanguageObject<any, SentenceContext>>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get styleDomain(): AglStyleDomain;
        get formatDomain(): AglFormatDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get completionProvider(): Nullable<CompletionProvider<Regex, SentenceContext>>;
        get parser(): RegexParser;
        private constructor();
    }
}
export declare abstract class AglScope {
    static readonly getInstance: () => typeof AglScope.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglScope.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor {
        get komposite(): string;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        private constructor();
    }
}
export declare class ItemInScope {
    constructor(referableName: string, qualifiedTypeName: QualifiedName, location: Nullable<any>, item: any);
    get referableName(): string;
    get qualifiedTypeName(): QualifiedName;
    get location(): Nullable<any>;
    get item(): any;
    copy(referableName?: string, qualifiedTypeName?: QualifiedName, location?: Nullable<any>, item?: any): ItemInScope;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ItemInScope.$metadata$ {
    const constructor: abstract new () => ItemInScope;
}
export declare interface Scope {
    readonly forTypeName: QualifiedName;
    readonly scopeIdentity: string;
    readonly scopePath: KtList<string>;
    readonly items: KtMap<string, KtMap<QualifiedName, any/* Pair<Nullable<any>, any> */>>;
    readonly childScopes: KtMap<string, Scope>;
    readonly rootScope: Scope;
    readonly isEmpty: boolean;
    clear(): void;
    contains(referableName: string, conformsToFunc: (p0: QualifiedName) => boolean): boolean;
    findItemsNamed(name: string): KtSet<ItemInScope>;
    findItemsConformingTo(conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsNamedConformingTo(name: string, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsByQualifiedName(qualifiedName: KtList<string>): KtSet<ItemInScope>;
    findItemsByQualifiedNameConformingTo(qualifiedName: KtList<string>, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    getChildScopeOrNull(childScopeIdentityInThis: string): Nullable<Scope>;
    createOrGetChildScope(childScopeIdentityInThis: string, forTypeName: QualifiedName): Scope;
    addToScope(referableName: string, qualifiedTypeName: QualifiedName, location: Nullable<any>, item: any, replaceIfAlreadyExists: boolean): boolean;
    removeItemsWithLocation(location: any): void;
    removeItemsIf(func: (p0: ItemInScope) => boolean): void;
    merge(other: Scope): void;
    asString(indent: Indent): string;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.scope.api.Scope": unique symbol;
    };
}
export declare class ScopeSimple implements Scope {
    constructor(parent: Nullable<ScopeSimple>, scopeIdentityInParent: string, forTypeName: QualifiedName);
    get parent(): Nullable<ScopeSimple>;
    get scopeIdentityInParent(): string;
    get forTypeName(): QualifiedName;
    get scopeIdentity(): string;
    get scopePath(): KtList<string>;
    get rootScope(): ScopeSimple;
    get childScopes(): KtMap<string, ScopeSimple>;
    get items(): KtMap<string, KtMap<QualifiedName, any/* Pair<Nullable<any>, any> */>>;
    get isEmpty(): boolean;
    clear(): void;
    contains(referableName: string, conformsToFunc: (p0: QualifiedName) => boolean): boolean;
    getChildScopeOrNull(childScopeIdentityInThis: string): Nullable<Scope>;
    createOrGetChildScope(childScopeIdentityInThis: string, forTypeName: QualifiedName): ScopeSimple;
    addToScope(referableName: string, qualifiedTypeName: QualifiedName, location: Nullable<any>, itemInScope: any, replaceIfAlreadyExists: boolean): boolean;
    merge(other: Scope): void;
    removeItemsWithLocation(location: any): void;
    removeItemsIf(func: (p0: ItemInScope) => boolean): void;
    findItemsNamed(name: string): KtSet<ItemInScope>;
    findItemsConformingTo(conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsNamedConformingTo(name: string, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    findItemsByQualifiedName(qualifiedName: KtList<string>): KtSet<ItemInScope>;
    findItemsByQualifiedNameConformingTo(qualifiedName: KtList<string>, conformsToFunc: (p0: QualifiedName) => boolean): KtList<ItemInScope>;
    asString(indent: Indent): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: Scope["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScopeSimple.$metadata$ {
    const constructor: abstract new () => ScopeSimple;
}
export declare namespace ScopeSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get ROOT_ID(): string;
            private constructor();
        }
    }
}
export declare abstract class AglStyle {
    static readonly getInstance: () => typeof AglStyle.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyle.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<AglStyleDomain, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get goalRuleName(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get styleDomain(): AglStyleDomain;
        get formatDomain(): AglFormatDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): Nullable<SyntaxAnalyser<AglStyleDomain>>;
        get semanticAnalyser(): Nullable<SemanticAnalyser<AglStyleDomain, SentenceContext>>;
        get completionProvider(): Nullable<CompletionProvider<AglStyleDomain, SentenceContext>>;
        private constructor();
    }
}
export declare class AglStyleCompletionProvider implements CompletionProvider<AglStyleDomain, SentenceContext> {
    constructor();
    provide(spines: KtSet<Spine>, options: CompletionProviderOptions<SentenceContext>): KtList<CompletionItem>;
    readonly __doNotUseOrImplementIt: CompletionProvider<AglStyleDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleCompletionProvider.$metadata$ {
    const constructor: abstract new () => AglStyleCompletionProvider;
}
export declare namespace AglStyleCompletionProvider {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class AglStyleSemanticAnalyser implements SemanticAnalyser<AglStyleDomain, SentenceContext> {
    constructor();
    get _issues(): IssueHolder;
    clear(): void;
    analyse(sentenceIdentity: Nullable<any>, asm: AglStyleDomain, locationMap: Nullable<LocationMap> | undefined, options: SemanticAnalysisOptions<SentenceContext>): SemanticAnalysisResult;
    readonly __doNotUseOrImplementIt: SemanticAnalyser<AglStyleDomain, SentenceContext>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleSemanticAnalyser.$metadata$ {
    const constructor: abstract new () => AglStyleSemanticAnalyser;
}
export declare namespace AglStyleSemanticAnalyser {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            findStyleSetOrNull(sentenceContext: SentenceContext, localNamespace: QualifiedName, nameOrQName: PossiblyQualifiedName): Nullable<StyleSet>;
            private constructor();
        }
    }
}
export declare class AglStyleDomainDefault extends DomainAbstract.$metadata$.constructor<StyleNamespace, StyleSet> implements AglStyleDomain {
    constructor(name: SimpleName, options?: OptionHolder, namespace?: KtList<StyleNamespace>);
    get name(): SimpleName;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: AglStyleDomain["__doNotUseOrImplementIt"] & DomainAbstract<StyleNamespace, StyleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleDomainDefault.$metadata$ {
    const constructor: abstract new () => AglStyleDomainDefault;
}
export declare namespace AglStyleDomainDefault {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get KEYWORD_STYLE_ID(): AglStyleSelector;
            get NO_STYLE_ID(): AglStyleSelector;
            fromString(context: SentenceContext, aglStyleModelSentence: StyleString): ProcessResult<AglStyleDomain>;
            private constructor();
        }
    }
}
export declare class StyleNamespaceDefault extends NamespaceAbstract.$metadata$.constructor<StyleSet> implements StyleNamespace {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    get styleSet(): KtList<StyleSet>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: StyleNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<StyleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleNamespaceDefault.$metadata$ {
    const constructor: abstract new () => StyleNamespaceDefault;
}
export declare class StyleSetReferenceDefault implements StyleSetReference {
    constructor(localNamespace: StyleNamespace, nameOrQName: PossiblyQualifiedName);
    get localNamespace(): StyleNamespace;
    get nameOrQName(): PossiblyQualifiedName;
    get resolved(): Nullable<StyleSet>;
    set resolved(value: Nullable<StyleSet>);
    resolveAs(resolved: StyleSet): void;
    copy(localNamespace?: StyleNamespace, nameOrQName?: PossiblyQualifiedName): StyleSetReferenceDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: StyleSetReference["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleSetReferenceDefault.$metadata$ {
    const constructor: abstract new () => StyleSetReferenceDefault;
}
export declare class AglStyleSetDefault extends DefinitionAbstract.$metadata$.constructor<StyleSet> implements StyleSet {
    constructor(namespace: StyleNamespace, name: SimpleName, _extends: KtList<StyleSetReference>, options?: OptionHolder);
    get namespace(): StyleNamespace;
    get name(): SimpleName;
    get extends(): KtList<StyleSetReference>;
    get options(): OptionHolder;
    get rules(): KtList<AglStyleRule>;
    get metaRules(): KtList<AglStyleMetaRule>;
    get tagRules(): KtList<AglStyleTagRule>;
    get allRules(): KtList<AglStyleRule>;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: StyleSet["__doNotUseOrImplementIt"] & DefinitionAbstract<StyleSet>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleSetDefault.$metadata$ {
    const constructor: abstract new () => AglStyleSetDefault;
}
export declare class AglStyleMetaRuleDefault implements AglStyleMetaRule {
    constructor(pattern: EscapedPattern);
    get pattern(): EscapedPattern;
    get declaration(): (KtMap<string, AglStyleDeclaration> & KtMutableMap<string, AglStyleDeclaration>)/* LinkedHashMap<string, AglStyleDeclaration> */;
    set declaration(value: (KtMap<string, AglStyleDeclaration> & KtMutableMap<string, AglStyleDeclaration>)/* LinkedHashMap<string, AglStyleDeclaration> */);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(pattern?: EscapedPattern): AglStyleMetaRuleDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: AglStyleMetaRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleMetaRuleDefault.$metadata$ {
    const constructor: abstract new () => AglStyleMetaRuleDefault;
}
export declare class AglStyleTagRuleDefault implements AglStyleTagRule {
    constructor(selector: KtList<AglStyleSelector>);
    get selector(): KtList<AglStyleSelector>;
    get declaration(): (KtMap<string, AglStyleDeclaration> & KtMutableMap<string, AglStyleDeclaration>)/* LinkedHashMap<string, AglStyleDeclaration> */;
    set declaration(value: (KtMap<string, AglStyleDeclaration> & KtMutableMap<string, AglStyleDeclaration>)/* LinkedHashMap<string, AglStyleDeclaration> */);
    asString(indent?: Indent, imports?: KtList<Import>): string;
    copy(selector?: KtList<AglStyleSelector>): AglStyleTagRuleDefault;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: AglStyleTagRule["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleTagRuleDefault.$metadata$ {
    const constructor: abstract new () => AglStyleTagRuleDefault;
}
export declare interface AglStyleDomain extends Domain<StyleNamespace, StyleSet> {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.AglStyleDomain": unique symbol;
    } & Domain<StyleNamespace, StyleSet>["__doNotUseOrImplementIt"];
}
export declare interface StyleNamespace extends Namespace<StyleSet> {
    readonly styleSet: KtList<StyleSet>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.StyleNamespace": unique symbol;
    } & Namespace<StyleSet>["__doNotUseOrImplementIt"];
}
export declare interface StyleSetReference {
    readonly localNamespace: StyleNamespace;
    readonly nameOrQName: PossiblyQualifiedName;
    readonly resolved: Nullable<StyleSet>;
    resolveAs(resolved: StyleSet): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.StyleSetReference": unique symbol;
    };
}
export declare interface StyleSet extends Definition<StyleSet> {
    readonly namespace: StyleNamespace;
    readonly extends: KtList<StyleSetReference>;
    readonly rules: KtList<AglStyleRule>;
    readonly metaRules: KtList<AglStyleMetaRule>;
    readonly tagRules: KtList<AglStyleTagRule>;
    readonly allRules: KtList<AglStyleRule>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.StyleSet": unique symbol;
    } & Definition<StyleSet>["__doNotUseOrImplementIt"];
}
export declare interface AglStyleRule extends Formatable {
    readonly declaration: KtMap<string, AglStyleDeclaration>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.AglStyleRule": unique symbol;
    } & Formatable["__doNotUseOrImplementIt"];
}
export declare interface AglStyleMetaRule extends AglStyleRule {
    readonly pattern: EscapedPattern;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.AglStyleMetaRule": unique symbol;
    } & AglStyleRule["__doNotUseOrImplementIt"];
}
export declare interface AglStyleTagRule extends AglStyleRule {
    readonly selector: KtList<AglStyleSelector>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.style.api.AglStyleTagRule": unique symbol;
    } & AglStyleRule["__doNotUseOrImplementIt"];
}
export declare abstract class AglStyleSelectorKind {
    private constructor();
    static get SPECIAL(): AglStyleSelectorKind & {
        get name(): "SPECIAL";
        get ordinal(): 0;
    };
    static get LITERAL(): AglStyleSelectorKind & {
        get name(): "LITERAL";
        get ordinal(): 1;
    };
    static get PATTERN(): AglStyleSelectorKind & {
        get name(): "PATTERN";
        get ordinal(): 2;
    };
    static get RULE_NAME(): AglStyleSelectorKind & {
        get name(): "RULE_NAME";
        get ordinal(): 3;
    };
    get name(): "SPECIAL" | "LITERAL" | "PATTERN" | "RULE_NAME";
    get ordinal(): 0 | 1 | 2 | 3;
    static values(): Array<AglStyleSelectorKind>;
    static valueOf(value: string): AglStyleSelectorKind;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleSelectorKind.$metadata$ {
    const constructor: abstract new () => AglStyleSelectorKind;
}
export declare class AglStyleSelector {
    constructor(value: string, kind: AglStyleSelectorKind);
    get value(): string;
    get kind(): AglStyleSelectorKind;
    copy(value?: string, kind?: AglStyleSelectorKind): AglStyleSelector;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleSelector.$metadata$ {
    const constructor: abstract new () => AglStyleSelector;
}
export declare class AglStyleDeclaration {
    constructor(name: string, value: string);
    get name(): string;
    get value(): string;
    copy(name?: string, value?: string): AglStyleDeclaration;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglStyleDeclaration.$metadata$ {
    const constructor: abstract new () => AglStyleDeclaration;
}
export declare function styleDomain(name: string, sentenceContext: SentenceContext, init: (p0: StyleDomainBuilder) => void): AglStyleDomain;
export declare class StyleDomainBuilder {
    constructor(_name: SimpleName);
    namespace(qualifiedName: string, init: (p0: StyleNamespaceBuilder) => void): void;
    build(): AglStyleDomain;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleDomainBuilder.$metadata$ {
    const constructor: abstract new () => StyleDomainBuilder;
}
export declare class StyleNamespaceBuilder {
    private constructor();
    styles(name: string, init: (p0: StylesBuilder) => void): void;
    build(): StyleNamespaceDefault;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleNamespaceBuilder.$metadata$ {
    const constructor: abstract new () => StyleNamespaceBuilder;
}
export declare class StylesBuilder {
    private constructor();
    extends(styleSetName: string): void;
    metaRule(unescapedPattern: string, init: (p0: StyleMetaRuleBuilder) => void): void;
    tagRule(tag: Array<string>, init: (p0: StyleTagRuleBuilder) => void): void;
    build(): AglStyleSetDefault;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StylesBuilder.$metadata$ {
    const constructor: abstract new () => StylesBuilder;
}
export declare class StyleMetaRuleBuilder {
    private constructor();
    declaration(name: string, value: string): void;
    build(): AglStyleMetaRuleDefault;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleMetaRuleBuilder.$metadata$ {
    const constructor: abstract new () => StyleMetaRuleBuilder;
}
export declare class StyleTagRuleBuilder {
    private constructor();
    declaration(name: string, value: string): void;
    build(): AglStyleTagRuleDefault;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StyleTagRuleBuilder.$metadata$ {
    const constructor: abstract new () => StyleTagRuleBuilder;
}
/** @deprecated Use StdLibDefault below */
export declare abstract class StdLibDefault1 {
    static readonly getInstance: () => typeof StdLibDefault1.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StdLibDefault1.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends TypesNamespaceAbstract.$metadata$.constructor {
        get qualifiedName(): QualifiedName;
        get AnyType(): TypeInstance;
        get NothingType(): TypeInstance;
        get String(): TypeInstance;
        get Boolean(): TypeInstance;
        get Integer(): TypeInstance;
        get Real(): TypeInstance;
        get Timestamp(): TypeInstance;
        get Exception(): TypeInstance;
        get Pair(): DataType;
        get Lambda(): TypeInstance;
        get TupleType(): TupleTypeSimple;
        get Collection(): CollectionType;
        get List(): CollectionType;
        get ListSeparated(): CollectionType;
        get Set(): CollectionType;
        get OrderedSet(): CollectionType;
        get Map(): CollectionType;
        findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
        createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
        asString(indent?: Indent, imports?: KtList<Import>): string;
        private constructor();
    }
}
export declare class FunctionDefinitionPrimitive extends FunctionDefinitionAbstract.$metadata$.constructor implements FunctionDefinitionFloating {
    constructor(name: SimpleName, parameters: KtList<FunctionParameter>, returnTypeReference: Nullable<TypeReference>, body: Nullable<Expression>);
    readonly __doNotUseOrImplementIt: FunctionDefinitionFloating["__doNotUseOrImplementIt"] & FunctionDefinitionAbstract["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace FunctionDefinitionPrimitive.$metadata$ {
    const constructor: abstract new () => FunctionDefinitionPrimitive;
}
export declare abstract class StdFunctionLib {
    static readonly getInstance: () => typeof StdFunctionLib.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StdFunctionLib.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements FunctionLib {
        get declaration(): KtMap<string, FunctionDefinitionFloating>;
        findFirstFunctionNamed(functionName: string): Nullable<FunctionDefinitionFloating>;
        readonly __doNotUseOrImplementIt: FunctionLib["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare abstract class StdLibDefault {
    static readonly getInstance: () => typeof StdLibDefault.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StdLibDefault.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends TypesNamespaceAbstract.$metadata$.constructor {
        get qualifiedName(): QualifiedName;
        get AnyType(): TypeInstance;
        get NothingType(): TypeInstance;
        get String(): TypeInstance;
        get Boolean(): TypeInstance;
        get Integer(): TypeInstance;
        get Real(): TypeInstance;
        get Timestamp(): TypeInstance;
        get Exception(): TypeInstance;
        get Pair(): DataType;
        get Lambda(): TypeInstance;
        get TupleType(): TupleTypeSimple;
        get Collection(): CollectionType;
        get Set(): CollectionType;
        get List(): CollectionType;
        get ListSeparated(): CollectionType;
        get OrderedSet(): CollectionType;
        get Map(): CollectionType;
        findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
        createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
        asString(indent?: Indent, imports?: KtList<Import>): string;
        private constructor();
    }
}
export declare abstract class TypeInstanceAbstract implements TypeInstance {
    constructor();
    get allResolvedProperty(): KtMap<PropertyName, PropertyDeclarationResolved>;
    get allResolvedMethod(): KtMap<MethodName, MethodDefinitionResolved>;
    get asTypeArgument(): TypeArgument;
    notNullable(): TypeInstance;
    nullable(): TypeInstance;
    signature(context: Nullable<TypesNamespace>, currentDepth: number): string;
    conformsTo(other: TypeInstance): boolean;
    commonSuperType(other: TypeInstance): TypeInstance;
    abstract hashCode(): number;
    abstract equals(other: Nullable<any>): boolean;
    toString(): string;
    protected createTypeArgMap(): KtMap<TypeParameter, TypeInstance>;
    abstract get namespace(): TypesNamespace;
    abstract get typeArguments(): KtList<TypeArgument>;
    abstract get isNullable(): boolean;
    abstract get typeName(): SimpleName;
    abstract get qualifiedTypeName(): QualifiedName;
    abstract get isNothing(): boolean;
    abstract get isPrimitive(): boolean;
    abstract get isCollection(): boolean;
    abstract get resolvedDefinition(): TypeDefinition;
    abstract get resolvedDefinitionOrNull(): Nullable<TypeDefinition>;
    abstract resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    abstract possiblyQualifiedNameInContext(context: TypesNamespace): any;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeInstance;
    readonly __doNotUseOrImplementIt: TypeInstance["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeInstanceAbstract.$metadata$ {
    const constructor: abstract new () => TypeInstanceAbstract;
}
export declare class TypeParameterReference extends TypeInstanceAbstract.$metadata$.constructor implements TypeInstance {
    constructor(context: TypeDefinition, typeParameterName: SimpleName, isNullable?: boolean);
    get context(): TypeDefinition;
    get typeParameterName(): SimpleName;
    get isNullable(): boolean;
    get namespace(): TypesNamespace;
    get qualifiedTypeName(): QualifiedName;
    get typeName(): SimpleName;
    get typeArguments(): KtList<TypeArgument>;
    get isNothing(): boolean;
    get isPrimitive(): boolean;
    get isCollection(): boolean;
    get resolvedDefinitionOrNull(): Nullable<TypeDefinition>;
    get resolvedDefinition(): TypeDefinition;
    conformsTo(other: TypeInstance): boolean;
    signature(context: Nullable<TypesNamespace>, currentDepth: number): string;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    possiblyQualifiedNameInContext(context: TypesNamespace): PossiblyQualifiedName;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeInstance;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: TypeInstanceAbstract["__doNotUseOrImplementIt"] & TypeInstance["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeParameterReference.$metadata$ {
    const constructor: abstract new () => TypeParameterReference;
}
export declare class TypeArgumentSimple implements TypeArgument {
    constructor(type: TypeInstance);
    get type(): TypeInstance;
    conformsTo(other: TypeArgument): boolean;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    signature(context: Nullable<TypesNamespace>, currentDepth: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeArgument;
    toString(): string;
    copy(type?: TypeInstance): TypeArgumentSimple;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: TypeArgument["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeArgumentSimple.$metadata$ {
    const constructor: abstract new () => TypeArgumentSimple;
}
export declare class TypeInstanceSimple extends TypeInstanceAbstract.$metadata$.constructor {
    constructor(contextQualifiedTypeName: Nullable<QualifiedName>, namespace: TypesNamespace, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments: KtList<TypeArgument>, isNullable: boolean);
    get contextQualifiedTypeName(): Nullable<QualifiedName>;
    get namespace(): TypesNamespace;
    get qualifiedOrImportedTypeName(): PossiblyQualifiedName;
    get typeArguments(): KtList<TypeArgument>;
    get isNullable(): boolean;
    get context(): Nullable<TypeDefinition>;
    get qualifiedNameOrNull(): Nullable<QualifiedName>;
    get qualifiedNameOrSimpleName(): PossiblyQualifiedName;
    get typeName(): SimpleName;
    get qualifiedTypeName(): QualifiedName;
    get isNothing(): boolean;
    get isPrimitive(): boolean;
    get isCollection(): boolean;
    get resolvedDefinitionOrNull(): Nullable<TypeDefinition>;
    get resolvedDefinition(): TypeDefinition;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    possiblyQualifiedNameInContext(context: TypesNamespace): PossiblyQualifiedName;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeInstance;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeInstanceSimple.$metadata$ {
    const constructor: abstract new () => TypeInstanceSimple;
}
export declare namespace TypeInstanceSimple {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            combineTypeArgMap(first: KtMap<TypeParameter, TypeInstance>, second: KtMap<TypeParameter, TypeInstance>): KtMap<TypeParameter, TypeInstance>;
            private constructor();
        }
    }
}
export declare class TupleTypeInstanceSimple extends TypeInstanceAbstract.$metadata$.constructor implements TupleTypeInstance {
    constructor(namespace: TypesNamespace, typeArguments: KtList<TypeArgumentNamed>, isNullable: boolean);
    get namespace(): TypesNamespace;
    get typeArguments(): KtList<TypeArgumentNamed>;
    get isNullable(): boolean;
    get typeName(): SimpleName;
    get qualifiedTypeName(): QualifiedName;
    get isNothing(): boolean;
    get isPrimitive(): boolean;
    get isCollection(): boolean;
    get resolvedDefinitionOrNull(): TypeDefinition;
    get resolvedDefinition(): TypeDefinition;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    protected createTypeArgMap(): KtMap<TypeParameter, TypeInstance>;
    possiblyQualifiedNameInContext(context: TypesNamespace): PossiblyQualifiedName;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeInstance;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: TypeInstanceAbstract["__doNotUseOrImplementIt"] & TupleTypeInstance["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TupleTypeInstanceSimple.$metadata$ {
    const constructor: abstract new () => TupleTypeInstanceSimple;
}
export declare class TypesNamespaceSimple extends TypesNamespaceAbstract.$metadata$.constructor {
    constructor(qualifiedName: QualifiedName, options?: OptionHolder, _import?: KtList<Import>);
    get qualifiedName(): QualifiedName;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
    createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypesNamespaceSimple.$metadata$ {
    const constructor: abstract new () => TypesNamespaceSimple;
}
export declare abstract class TypesNamespaceAbstract extends NamespaceAbstract.$metadata$.constructor<TypeDefinition> implements TypesNamespace {
    constructor(options: OptionHolder, _import: KtList<Import>);
    get import(): KtList<Import>;
    get ownedTypesByName(): KtMap<SimpleName, TypeDefinition>;
    get ownedTypes(): any/* Collection<TypeDefinition> */;
    get ownedUnnamedSupertypeType(): KtMutableList<UnionType>;
    get ownedTupleTypes(): KtMutableList<TupleType>;
    get singletonType(): KtSet<SingletonType>;
    get primitiveType(): KtSet<PrimitiveType>;
    get valueType(): KtSet<ValueType>;
    get enumType(): KtSet<EnumType>;
    get collectionType(): KtSet<CollectionType>;
    get interfaceType(): KtSet<InterfaceType>;
    get dataType(): KtSet<DataType>;
    isImported(qualifiedNamespaceName: QualifiedName): boolean;
    findOwnedTypeNamed(typeName: SimpleName): Nullable<TypeDefinition>;
    findTypeNamed(qualifiedOrImportedTypeName: PossiblyQualifiedName): Nullable<TypeDefinition>;
    findOwnedUnnamedSupertypeTypeOrNull(subtypes: KtList<TypeInstance>): Nullable<UnionType>;
    /** @deprecated No longer needed */
    findTupleTypeWithIdOrNull(id: number): Nullable<TupleType>;
    findOwnedSpecialTypeNamedOrNull(typeName: SimpleName): Nullable<SpecialTypeSimple>;
    findOwnedSingletonTypeNamedOrNull(typeName: SimpleName): Nullable<SingletonType>;
    findOwnedPrimitiveTypeNamedOrNull(typeName: SimpleName): Nullable<PrimitiveType>;
    findOwnedEnumTypeNamedOrNull(typeName: SimpleName): Nullable<EnumType>;
    findOwnedCollectionTypeNamedOrNull(typeName: SimpleName): Nullable<CollectionType>;
    findOwnedValueTypeNamedOrNull(typeName: SimpleName): Nullable<ValueType>;
    findOwnedInterfaceTypeNamedOrNull(typeName: SimpleName): Nullable<InterfaceType>;
    findOwnedDataTypeNamedOrNull(typeName: SimpleName): Nullable<DataType>;
    findOwnedUnionTypeNamedOrNull(typeName: SimpleName): Nullable<UnionType>;
    createOwnedDataTypeNamed(typeName: SimpleName): DataType;
    findOwnedOrCreateSpecialTypeNamed(typeName: SimpleName): SpecialTypeSimple;
    findOwnedOrCreateSingletonTypeNamed(typeName: SimpleName): SingletonType;
    findOwnedOrCreatePrimitiveTypeNamed(typeName: SimpleName): PrimitiveType;
    findOwnedOrCreateEnumTypeNamed(typeName: SimpleName, literals: KtList<string>): EnumType;
    findOwnedOrCreateCollectionTypeNamed(typeName: SimpleName, typeParameters: KtList<TypeParameter>): CollectionType;
    findOwnedOrCreateValueTypeNamed(typeName: SimpleName): ValueType;
    findOwnedOrCreateInterfaceTypeNamed(typeName: SimpleName): InterfaceType;
    findOwnedOrCreateDataTypeNamed(typeName: SimpleName): DataType;
    findOwnedOrCreateUnionTypeNamed(typeName: SimpleName, ifCreate: (p0: UnionType) => void): UnionType;
    findOrCreateAssociation(ends: KtList<AssociationEnd>): KtList<PropertyDeclaration>;
    createTupleType(): TupleType;
    createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    createTupleTypeInstance(typeArguments: KtList<TypeArgumentNamed>, nullable: boolean): TupleTypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
    abstract get qualifiedName(): QualifiedName;
    readonly __doNotUseOrImplementIt: TypesNamespace["__doNotUseOrImplementIt"] & NamespaceAbstract<TypeDefinition>["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypesNamespaceAbstract.$metadata$ {
    const constructor: abstract new () => TypesNamespaceAbstract;
}
export declare class TypeParameterSimple implements TypeParameter {
    constructor(name: SimpleName);
    get name(): SimpleName;
    clone(): TypeParameter;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: TypeParameter["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeParameterSimple.$metadata$ {
    const constructor: abstract new () => TypeParameterSimple;
}
export declare abstract class TypeParameterMultiple {
    static readonly getInstance: () => typeof TypeParameterMultiple.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeParameterMultiple.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements TypeParameter {
        get name(): SimpleName;
        clone(): TypeParameter;
        readonly __doNotUseOrImplementIt: TypeParameter["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare abstract class TypeDefinitionSimpleAbstract implements TypeDefinition {
    constructor(options?: OptionHolder);
    get options(): OptionHolder;
    get qualifiedName(): QualifiedName;
    get supertypes(): KtList<TypeInstance>;
    get subtypes(): KtList<TypeInstance>;
    get typeParameters(): KtList<TypeParameter>;
    get propertyByIndex(): KtMutableMap<number, PropertyDeclaration>;
    get property(): KtList<PropertyDeclaration>;
    get method(): KtMutableList<MethodDefinition>;
    get allSuperTypes(): KtList<TypeInstance>;
    get allProperty(): KtMap<PropertyName, PropertyDeclaration>;
    get allMethod(): KtMap<MethodName, MethodDefinition>;
    get metaInfo(): KtMutableMap<string, string>;
    set metaInfo(value: KtMutableMap<string, string>);
    get implementation(): Nullable<any>/* Nullable<KClass<UnknownType *>> */;
    set implementation(value: Nullable<any>/* Nullable<KClass<UnknownType *>> */);
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    conformsTo(other: TypeDefinition): boolean;
    getOwnedPropertyByIndexOrNull(i: number): Nullable<PropertyDeclaration>;
    findOwnedPropertyOrNull(name: PropertyName): Nullable<PropertyDeclaration>;
    findAllPropertyOrNull(name: PropertyName): Nullable<PropertyDeclaration>;
    findOwnedMethodOrNull(name: MethodName): Nullable<MethodDefinition>;
    findAllMethodOrNull(name: MethodName): Nullable<MethodDefinition>;
    addTypeParameter(name: TypeParameter): void;
    addSupertype_dep(qualifiedTypeName: PossiblyQualifiedName, typeArgNames: KtList<PossiblyQualifiedName>): void;
    addSupertype(typeInstance: TypeInstance): void;
    appendPropertyDerived(name: PropertyName, typeInstance: TypeInstance, description: string, expression: string): PropertyDeclarationDerived;
    appendPropertyPrimitive(name: PropertyName, typeInstance: TypeInstance, description: string): PropertyDeclarationPrimitive;
    appendMethodPrimitive(name: MethodName, parameters: KtList<ParameterDeclaration>, returnType: TypeInstance, description: string): MethodDefinitionPrimitive;
    appendMethodDerived(name: MethodName, parameters: KtList<ParameterDeclaration>, typeInstance: TypeInstance, description: string, body: string): MethodDefinitionDerived;
    asStringInContext(context: TypesNamespace): string;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    protected findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, clone: TypeDefinitionSimpleAbstract): void;
    addProperty(propertyDeclaration: PropertyDeclaration): void;
    addMethod(methodDefinition: MethodDefinition): void;
    abstract get namespace(): TypesNamespace;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeDefinition;
    abstract get name(): SimpleName;
    readonly __doNotUseOrImplementIt: TypeDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeDefinitionSimpleAbstract.$metadata$ {
    const constructor: abstract new () => TypeDefinitionSimpleAbstract;
}
export declare namespace TypeDefinitionSimpleAbstract {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get maxDepth(): number;
            private constructor();
        }
    }
}
export declare class SpecialTypeSimple extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements SpecialType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): SpecialTypeSimple;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & SpecialType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SpecialTypeSimple.$metadata$ {
    const constructor: abstract new () => SpecialTypeSimple;
}
export declare class SingletonTypeSimple extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements SingletonType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): SingletonType;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & SingletonType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SingletonTypeSimple.$metadata$ {
    const constructor: abstract new () => SingletonTypeSimple;
}
export declare class PrimitiveTypeSimple extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements PrimitiveType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PrimitiveType;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & PrimitiveType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PrimitiveTypeSimple.$metadata$ {
    const constructor: abstract new () => PrimitiveTypeSimple;
}
export declare class EnumTypeSimple extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements EnumType {
    constructor(namespace: TypesNamespace, name: SimpleName, literals: KtList<string>);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get literals(): KtList<string>;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): EnumType;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & EnumType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EnumTypeSimple.$metadata$ {
    const constructor: abstract new () => EnumTypeSimple;
}
export declare class UnionTypeSimple extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements UnionType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get alternatives(): KtMutableList<TypeInstance>;
    addAlternative(value: TypeInstance): void;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    conformsTo(other: TypeDefinition): boolean;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): UnionType;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & UnionType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace UnionTypeSimple.$metadata$ {
    const constructor: abstract new () => UnionTypeSimple;
}
export declare abstract class StructuredTypeSimpleAbstract extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements StructuredType {
    constructor();
    propertiesWithCharacteristic(chr: PropertyCharacteristic): KtList<PropertyDeclaration>;
    appendPropertyStored(name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index?: number): PropertyDeclaration;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): StructuredType;
    abstract get namespace(): TypesNamespace;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    abstract get name(): SimpleName;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & StructuredType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace StructuredTypeSimpleAbstract.$metadata$ {
    const constructor: abstract new () => StructuredTypeSimpleAbstract;
}
export declare class TypeArgumentNamedSimple implements TypeArgumentNamed {
    constructor(name: PropertyName, type: TypeInstance);
    get name(): PropertyName;
    get type(): TypeInstance;
    conformsTo(other: TypeArgument): boolean;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    signature(context: Nullable<TypesNamespace>, currentDepth: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeArgumentNamed;
    toString(): string;
    readonly __doNotUseOrImplementIt: TypeArgumentNamed["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeArgumentNamedSimple.$metadata$ {
    const constructor: abstract new () => TypeArgumentNamedSimple;
}
export declare class TupleTypeSimple extends TypeDefinitionSimpleAbstract.$metadata$.constructor implements TupleType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get typeParameters(): KtList<typeof TypeParameterMultiple.$metadata$.type>;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TupleTypeInstance;
    typeTuple(typeArguments: KtList<TypeArgumentNamed>, nullable?: boolean): TupleTypeInstance;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TupleType;
    conformsTo(other: TypeDefinition): boolean;
    equalTo(other: TupleType): boolean;
    asStringInContext(context: TypesNamespace): string;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: TypeDefinitionSimpleAbstract["__doNotUseOrImplementIt"] & TupleType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TupleTypeSimple.$metadata$ {
    const constructor: abstract new () => TupleTypeSimple;
}
export declare class ValueTypeSimple extends StructuredTypeSimpleAbstract.$metadata$.constructor implements ValueType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get constructors(): KtList<ConstructorDefinition>;
    get valueProperty(): PropertyDeclaration;
    addConstructor(parameters: KtList<ParameterDeclaration>): void;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ValueType;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    appendPropertyStored(name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index?: number): PropertyDeclaration;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: StructuredTypeSimpleAbstract["__doNotUseOrImplementIt"] & ValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ValueTypeSimple.$metadata$ {
    const constructor: abstract new () => ValueTypeSimple;
}
export declare class InterfaceTypeSimple extends StructuredTypeSimpleAbstract.$metadata$.constructor implements InterfaceType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get subtypes(): KtMutableList<TypeInstance>;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): InterfaceType;
    addSubtype(typeInstance: TypeInstance): void;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    appendPropertyStored(name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index?: number): PropertyDeclaration;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: StructuredTypeSimpleAbstract["__doNotUseOrImplementIt"] & InterfaceType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace InterfaceTypeSimple.$metadata$ {
    const constructor: abstract new () => InterfaceTypeSimple;
}
export declare class DataTypeSimple extends StructuredTypeSimpleAbstract.$metadata$.constructor implements DataType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get constructors(): KtList<ConstructorDefinition>;
    get subtypes(): KtMutableList<TypeInstance>;
    addConstructor(parameters: KtList<ParameterDeclaration>): void;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): DataType;
    /** @deprecated Create a TypeInstance and use addSubtype(TypeInstance) */
    addSubtype_dep(qualifiedTypeName: PossiblyQualifiedName): void;
    addSubtype(typeInstance: TypeInstance): void;
    asStringInContext(context: TypesNamespace): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    appendPropertyStored(name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index?: number): PropertyDeclaration;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: StructuredTypeSimpleAbstract["__doNotUseOrImplementIt"] & DataType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DataTypeSimple.$metadata$ {
    const constructor: abstract new () => DataTypeSimple;
}
export declare class CollectionTypeSimple extends StructuredTypeSimpleAbstract.$metadata$.constructor implements CollectionType {
    constructor(namespace: TypesNamespace, name: SimpleName);
    get namespace(): TypesNamespace;
    get name(): SimpleName;
    get isStdList(): boolean;
    get isStdSet(): boolean;
    get isStdMap(): boolean;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): CollectionType;
    asStringInContext(context: TypesNamespace): string;
    appendPropertyStored(name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index?: number): PropertyDeclaration;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    asString(indent?: Indent, imports?: KtList<Import>): string;
    readonly __doNotUseOrImplementIt: StructuredTypeSimpleAbstract["__doNotUseOrImplementIt"] & CollectionType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CollectionTypeSimple.$metadata$ {
    const constructor: abstract new () => CollectionTypeSimple;
}
export declare class ConstructorDefinitionSimple implements ConstructorDefinition {
    constructor(owner: TypeDefinition, parameters: KtList<ParameterDeclaration>);
    get owner(): TypeDefinition;
    get parameters(): KtList<ParameterDeclaration>;
    get execution(): Nullable<(p0: KtList<any /*UnknownType **/>) => Nullable<any>>;
    set execution(value: Nullable<(p0: KtList<any /*UnknownType **/>) => Nullable<any>>);
    get executionSuspend(): Nullable<any /*Suspend functions are not supported*/>;
    set executionSuspend(value: Nullable<any /*Suspend functions are not supported*/>);
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ConstructorDefinition;
    readonly __doNotUseOrImplementIt: ConstructorDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ConstructorDefinitionSimple.$metadata$ {
    const constructor: abstract new () => ConstructorDefinitionSimple;
}
export declare abstract class PropertyDeclarationAbstract implements PropertyDeclaration {
    constructor();
    get metaInfo(): KtMutableMap<string, string>;
    set metaInfo(value: KtMutableMap<string, string>);
    get isConstructor(): boolean;
    get isIdentity(): boolean;
    get isComposite(): boolean;
    get isReference(): boolean;
    get isReadOnly(): boolean;
    get isReadWrite(): boolean;
    get isDerived(): boolean;
    get isStored(): boolean;
    get isPrimitive(): boolean;
    get opposite(): KtList<PropertyDeclaration>;
    set opposite(value: KtList<PropertyDeclaration>);
    get execution(): Nullable<(p0: any) => Nullable<any>>;
    set execution(value: Nullable<(p0: any) => Nullable<any>>);
    get executionSuspend(): Nullable<any /*Suspend functions are not supported*/>;
    set executionSuspend(value: Nullable<any /*Suspend functions are not supported*/>);
    resolved(typeArguments: KtMap<TypeParameter, TypeInstance>): PropertyDeclarationResolved;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    abstract get owner(): TypeDefinition;
    abstract get name(): PropertyName;
    abstract get typeInstance(): TypeInstance;
    abstract get characteristics(): KtSet<PropertyCharacteristic>;
    abstract get description(): string;
    abstract get index(): number;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PropertyDeclaration;
    readonly __doNotUseOrImplementIt: PropertyDeclaration["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyDeclarationAbstract.$metadata$ {
    const constructor: abstract new () => PropertyDeclarationAbstract;
}
export declare class PropertyDeclarationStored extends PropertyDeclarationAbstract.$metadata$.constructor {
    constructor(owner: StructuredType, name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index: number);
    get owner(): StructuredType;
    get name(): PropertyName;
    get typeInstance(): TypeInstance;
    get characteristics(): KtSet<PropertyCharacteristic>;
    get index(): number;
    get description(): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PropertyDeclaration;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyDeclarationStored.$metadata$ {
    const constructor: abstract new () => PropertyDeclarationStored;
}
export declare class PropertyDeclarationPrimitive extends PropertyDeclarationAbstract.$metadata$.constructor {
    constructor(owner: TypeDefinition, name: PropertyName, typeInstance: TypeInstance, description: string, index: number);
    get owner(): TypeDefinition;
    get name(): PropertyName;
    get typeInstance(): TypeInstance;
    get description(): string;
    get index(): number;
    get characteristics(): KtSet<PropertyCharacteristic>;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PropertyDeclaration;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyDeclarationPrimitive.$metadata$ {
    const constructor: abstract new () => PropertyDeclarationPrimitive;
}
export declare class PropertyDeclarationDerived extends PropertyDeclarationAbstract.$metadata$.constructor {
    constructor(owner: TypeDefinition, name: PropertyName, typeInstance: TypeInstance, description: string, expression: string, index: number);
    get owner(): TypeDefinition;
    get name(): PropertyName;
    get typeInstance(): TypeInstance;
    get description(): string;
    get expression(): string;
    get index(): number;
    get characteristics(): KtSet<PropertyCharacteristic>;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PropertyDeclaration;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyDeclarationDerived.$metadata$ {
    const constructor: abstract new () => PropertyDeclarationDerived;
}
export declare class PropertyDeclarationResolvedSimple extends PropertyDeclarationAbstract.$metadata$.constructor implements PropertyDeclarationResolved {
    constructor(original: PropertyDeclaration, owner: TypeDefinition, name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, description: string);
    get original(): PropertyDeclaration;
    get owner(): TypeDefinition;
    get name(): PropertyName;
    get typeInstance(): TypeInstance;
    get characteristics(): KtSet<PropertyCharacteristic>;
    get description(): string;
    get index(): number;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PropertyDeclaration;
    readonly __doNotUseOrImplementIt: PropertyDeclarationAbstract["__doNotUseOrImplementIt"] & PropertyDeclarationResolved["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyDeclarationResolvedSimple.$metadata$ {
    const constructor: abstract new () => PropertyDeclarationResolvedSimple;
}
export declare abstract class MethodDefinitionAbstract implements MethodDefinition {
    constructor();
    get execution(): Nullable<(p0: any, p1: KtList<any /*UnknownType **/>) => Nullable<any>>;
    set execution(value: Nullable<(p0: any, p1: KtList<any /*UnknownType **/>) => Nullable<any>>);
    get executionSuspend(): Nullable<any /*Suspend functions are not supported*/>;
    set executionSuspend(value: Nullable<any /*Suspend functions are not supported*/>);
    resolved(typeArguments: KtMap<TypeParameter, TypeInstance>): MethodDefinitionResolved;
    abstract get owner(): TypeDefinition;
    abstract get name(): MethodName;
    abstract get parameters(): KtList<ParameterDeclaration>;
    abstract get returnType(): TypeInstance;
    abstract get description(): string;
    abstract findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): MethodDefinition;
    readonly __doNotUseOrImplementIt: MethodDefinition["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MethodDefinitionAbstract.$metadata$ {
    const constructor: abstract new () => MethodDefinitionAbstract;
}
export declare class MethodDefinitionDerivedSimple extends MethodDefinitionAbstract.$metadata$.constructor implements MethodDefinitionDerived {
    constructor(owner: TypeDefinition, name: MethodName, parameters: KtList<ParameterDeclaration>, returnType: TypeInstance, description: string, body: string);
    get owner(): TypeDefinition;
    get name(): MethodName;
    get parameters(): KtList<ParameterDeclaration>;
    get returnType(): TypeInstance;
    get description(): string;
    get body(): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): MethodDefinitionDerived;
    readonly __doNotUseOrImplementIt: MethodDefinitionAbstract["__doNotUseOrImplementIt"] & MethodDefinitionDerived["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MethodDefinitionDerivedSimple.$metadata$ {
    const constructor: abstract new () => MethodDefinitionDerivedSimple;
}
export declare class MethodDefinitionResolvedSimple extends MethodDefinitionAbstract.$metadata$.constructor implements MethodDefinitionResolved {
    constructor(original: MethodDefinition, owner: TypeDefinition, name: MethodName, parameters: KtList<ParameterDeclaration>, returnType: TypeInstance, description: string);
    get original(): MethodDefinition;
    get owner(): TypeDefinition;
    get name(): MethodName;
    get parameters(): KtList<ParameterDeclaration>;
    get returnType(): TypeInstance;
    get description(): string;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): MethodDefinition;
    readonly __doNotUseOrImplementIt: MethodDefinitionAbstract["__doNotUseOrImplementIt"] & MethodDefinitionResolved["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MethodDefinitionResolvedSimple.$metadata$ {
    const constructor: abstract new () => MethodDefinitionResolvedSimple;
}
export declare class ParameterDefinitionSimple implements ParameterDeclaration {
    constructor(name: TmParameterName, typeInstance: TypeInstance, defaultValue: Nullable<string>);
    get name(): TmParameterName;
    get typeInstance(): TypeInstance;
    get defaultValue(): Nullable<string>;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ParameterDeclaration;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    toString(): string;
    readonly __doNotUseOrImplementIt: ParameterDeclaration["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ParameterDefinitionSimple.$metadata$ {
    const constructor: abstract new () => ParameterDefinitionSimple;
}
export declare abstract class AglTypes {
    static readonly getInstance: () => typeof AglTypes.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AglTypes.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor extends LanguageObjectAbstract.$metadata$.constructor<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, SentenceContext> {
        get NAMESPACE_NAME(): string;
        get NAME(): string;
        get goalRuleName(): string;
        get identity(): LanguageIdentity;
        get extends(): KtList<typeof AglBase.$metadata$.type>;
        get grammarString(): string;
        get typesString(): string;
        get kompositeString(): string;
        get asmTransformString(): string;
        get crossReferenceString(): string;
        get styleString(): string;
        get formatString(): string;
        get grammarDomain(): GrammarDomain;
        get typesDomain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
        get asmTransformDomain(): AsmTransformDomain;
        get crossReferenceDomain(): CrossReferenceDomain;
        get styleDomain(): AglStyleDomain;
        get formatDomain(): AglFormatDomain;
        get defaultTargetGrammar(): Grammar;
        get defaultTargetGoalRule(): string;
        get syntaxAnalyser(): SyntaxAnalyser<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */>;
        get semanticAnalyser(): Nullable<SemanticAnalyser<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, SentenceContext>>;
        get completionProvider(): Nullable<CompletionProvider<Domain<TypesNamespace, TypeDefinition>/* TypesDomain */, SentenceContext>>;
        private constructor();
    }
}
export declare class AssociationEnd {
    constructor(endName: PropertyName, endType: DataType, isNullable: boolean, collectionTypeName: Nullable<PossiblyQualifiedName>, characteristics: KtSet<PropertyCharacteristic>, navigable: boolean);
    get endName(): PropertyName;
    get endType(): DataType;
    get isNullable(): boolean;
    get collectionTypeName(): Nullable<PossiblyQualifiedName>;
    get characteristics(): KtSet<PropertyCharacteristic>;
    get navigable(): boolean;
    get byEvaluation(): Nullable<(p0: PropertyDeclaration) => Nullable<(p0: any) => Nullable<any>>>;
    set byEvaluation(value: Nullable<(p0: PropertyDeclaration) => Nullable<(p0: any) => Nullable<any>>>);
    get byEvaluationSuspend(): Nullable<(p0: PropertyDeclaration) => Nullable<any /*Suspend functions are not supported*/>>;
    set byEvaluationSuspend(value: Nullable<(p0: PropertyDeclaration) => Nullable<any /*Suspend functions are not supported*/>>);
    copy(endName?: PropertyName, endType?: DataType, isNullable?: boolean, collectionTypeName?: Nullable<PossiblyQualifiedName>, characteristics?: KtSet<PropertyCharacteristic>, navigable?: boolean): AssociationEnd;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AssociationEnd.$metadata$ {
    const constructor: abstract new () => AssociationEnd;
}
export declare interface TypesNamespace extends Namespace<TypeDefinition> {
    readonly ownedTypesByName: KtMap<SimpleName, TypeDefinition>;
    readonly ownedTypes: any/* Collection<TypeDefinition> */;
    readonly singletonType: KtSet<SingletonType>;
    readonly primitiveType: KtSet<PrimitiveType>;
    readonly valueType: KtSet<ValueType>;
    readonly enumType: KtSet<EnumType>;
    readonly collectionType: KtSet<CollectionType>;
    readonly interfaceType: KtSet<InterfaceType>;
    readonly dataType: KtSet<DataType>;
    isImported(qualifiedNamespaceName: QualifiedName): boolean;
    findOwnedTypeNamed(typeName: SimpleName): Nullable<TypeDefinition>;
    findTypeNamed(qualifiedOrImportedTypeName: PossiblyQualifiedName): Nullable<TypeDefinition>;
    findOwnedUnnamedSupertypeTypeOrNull(subtypes: KtList<TypeInstance>): Nullable<UnionType>;
    /** @deprecated No longer needed */
    findTupleTypeWithIdOrNull(id: number): Nullable<TupleType>;
    findOwnedSingletonTypeNamedOrNull(typeName: SimpleName): Nullable<SingletonType>;
    findOwnedPrimitiveTypeNamedOrNull(typeName: SimpleName): Nullable<PrimitiveType>;
    findOwnedEnumTypeNamedOrNull(typeName: SimpleName): Nullable<EnumType>;
    findOwnedValueTypeNamedOrNull(typeName: SimpleName): Nullable<ValueType>;
    findOwnedInterfaceTypeNamedOrNull(typeName: SimpleName): Nullable<InterfaceType>;
    findOwnedDataTypeNamedOrNull(typeName: SimpleName): Nullable<DataType>;
    findOwnedCollectionTypeNamedOrNull(typeName: SimpleName): Nullable<CollectionType>;
    findOwnedUnionTypeNamedOrNull(typeName: SimpleName): Nullable<UnionType>;
    createOwnedDataTypeNamed(typeName: SimpleName): DataType;
    findOwnedOrCreateSingletonTypeNamed(typeName: SimpleName): SingletonType;
    findOwnedOrCreatePrimitiveTypeNamed(typeName: SimpleName): PrimitiveType;
    findOwnedOrCreateEnumTypeNamed(typeName: SimpleName, literals: KtList<string>): EnumType;
    findOwnedOrCreateValueTypeNamed(typeName: SimpleName): ValueType;
    findOwnedOrCreateInterfaceTypeNamed(typeName: SimpleName): InterfaceType;
    findOwnedOrCreateDataTypeNamed(typeName: SimpleName): DataType;
    findOwnedOrCreateCollectionTypeNamed(typeName: SimpleName, typeParameters: KtList<TypeParameter>): CollectionType;
    findOwnedOrCreateUnionTypeNamed(typeName: SimpleName, ifCreate: (p0: UnionType) => void): UnionType;
    findOrCreateAssociation(ends: KtList<AssociationEnd>): KtList<PropertyDeclaration>;
    createTypeInstance(contextQualifiedTypeName: Nullable<QualifiedName>, qualifiedOrImportedTypeName: PossiblyQualifiedName, typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    createTupleTypeInstance(typeArguments: KtList<TypeArgumentNamed>, nullable: boolean): TupleTypeInstance;
    createTupleType(): TupleType;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypesNamespace;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TypesNamespace": unique symbol;
    } & Namespace<TypeDefinition>["__doNotUseOrImplementIt"];
}
export declare interface TypeParameter {
    readonly name: SimpleName;
    clone(): TypeParameter;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TypeParameter": unique symbol;
    };
}
export declare interface TypeArgument {
    readonly type: TypeInstance;
    conformsTo(other: TypeArgument): boolean;
    signature(context: Nullable<TypesNamespace>, currentDepth: number): string;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeArgument;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TypeArgument": unique symbol;
    };
}
export declare interface TypeInstance {
    readonly namespace: TypesNamespace;
    readonly typeArguments: KtList<TypeArgument>;
    readonly isNullable: boolean;
    readonly typeName: SimpleName;
    readonly qualifiedTypeName: QualifiedName;
    readonly isNothing: boolean;
    readonly isPrimitive: boolean;
    readonly isCollection: boolean;
    readonly resolvedDefinition: TypeDefinition;
    readonly resolvedDefinitionOrNull: Nullable<TypeDefinition>;
    readonly allResolvedProperty: KtMap<PropertyName, PropertyDeclarationResolved>;
    readonly allResolvedMethod: KtMap<MethodName, MethodDefinitionResolved>;
    readonly asTypeArgument: TypeArgument;
    resolved(resolvingTypeArguments: KtMap<TypeParameter, TypeInstance>): TypeInstance;
    notNullable(): TypeInstance;
    nullable(): TypeInstance;
    signature(context: Nullable<TypesNamespace>, currentDepth: number): string;
    conformsTo(other: TypeInstance): boolean;
    commonSuperType(other: TypeInstance): TypeInstance;
    possiblyQualifiedNameInContext(context: TypesNamespace): any;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeInstance;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TypeInstance": unique symbol;
    };
}
export declare interface TypeArgumentNamed extends TypeArgument {
    readonly name: PropertyName;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeArgumentNamed;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TypeArgumentNamed": unique symbol;
    } & TypeArgument["__doNotUseOrImplementIt"];
}
export declare interface TupleTypeInstance extends TypeInstance {
    readonly typeArguments: KtList<TypeArgumentNamed>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TupleTypeInstance": unique symbol;
    } & TypeInstance["__doNotUseOrImplementIt"];
}
export declare interface TypeDefinition extends Definition<TypeDefinition> {
    readonly namespace: TypesNamespace;
    readonly supertypes: KtList<TypeInstance>;
    readonly subtypes: KtList<TypeInstance>;
    readonly typeParameters: KtList<TypeParameter>;
    readonly property: KtList<PropertyDeclaration>;
    readonly method: KtList<MethodDefinition>;
    readonly allSuperTypes: KtList<TypeInstance>;
    readonly allProperty: KtMap<PropertyName, PropertyDeclaration>;
    readonly allMethod: KtMap<MethodName, MethodDefinition>;
    readonly metaInfo: KtMap<string, string>;
    readonly implementation: Nullable<any>/* Nullable<KClass<UnknownType *>> */;
    signature(context: Nullable<TypesNamespace>, currentDepth?: number): string;
    type(typeArguments?: KtList<TypeArgument>, isNullable?: boolean): TypeInstance;
    conformsTo(other: TypeDefinition): boolean;
    getOwnedPropertyByIndexOrNull(i: number): Nullable<PropertyDeclaration>;
    findOwnedPropertyOrNull(name: PropertyName): Nullable<PropertyDeclaration>;
    findAllPropertyOrNull(name: PropertyName): Nullable<PropertyDeclaration>;
    findOwnedMethodOrNull(name: MethodName): Nullable<MethodDefinition>;
    findAllMethodOrNull(name: MethodName): Nullable<MethodDefinition>;
    asStringInContext(context: TypesNamespace): string;
    addTypeParameter(name: TypeParameter): void;
    /** @deprecated Create a TypeInstance and use addSupertype(TypeInstance). This (deprecated) method does not add TypeArgs to the supertype. */
    addSupertype_dep(qualifiedTypeName: PossiblyQualifiedName, typeArgNames: KtList<PossiblyQualifiedName>): void;
    addSupertype(typeInstance: TypeInstance): void;
    appendPropertyPrimitive(name: PropertyName, typeInstance: TypeInstance, description: string): PropertyDeclaration;
    appendPropertyDerived(name: PropertyName, typeInstance: TypeInstance, description: string, expression: string): PropertyDeclaration;
    appendMethodPrimitive(name: MethodName, parameters: KtList<ParameterDeclaration>, returnType: TypeInstance, description: string): MethodDefinitionPrimitive;
    appendMethodDerived(name: MethodName, parameters: KtList<ParameterDeclaration>, typeInstance: TypeInstance, description: string, body: string): MethodDefinitionDerived;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): TypeDefinition;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TypeDefinition": unique symbol;
    } & Definition<TypeDefinition>["__doNotUseOrImplementIt"];
}
export declare interface SpecialType extends TypeDefinition {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.SpecialType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface SingletonType extends TypeDefinition {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.SingletonType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface PrimitiveType extends TypeDefinition {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.PrimitiveType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface EnumType extends TypeDefinition {
    readonly literals: KtList<string>;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.EnumType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface StructuredType extends TypeDefinition {
    propertiesWithCharacteristic(chr: PropertyCharacteristic): KtList<PropertyDeclaration>;
    appendPropertyStored(name: PropertyName, typeInstance: TypeInstance, characteristics: KtSet<PropertyCharacteristic>, index?: number): PropertyDeclaration;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): StructuredType;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.StructuredType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface TupleType extends TypeDefinition {
    typeTuple(typeArguments: KtList<TypeArgumentNamed>, nullable?: boolean): TupleTypeInstance;
    equalTo(other: TupleType): boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.TupleType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface ValueType extends StructuredType {
    readonly constructors: KtList<ConstructorDefinition>;
    readonly valueProperty: PropertyDeclaration;
    addConstructor(parameters: KtList<ParameterDeclaration>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.ValueType": unique symbol;
    } & StructuredType["__doNotUseOrImplementIt"];
}
export declare interface InterfaceType extends StructuredType {
    readonly subtypes: KtList<TypeInstance>;
    addSubtype(typeInstance: TypeInstance): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.InterfaceType": unique symbol;
    } & StructuredType["__doNotUseOrImplementIt"];
}
export declare interface DataType extends StructuredType {
    readonly subtypes: KtList<TypeInstance>;
    readonly constructors: KtList<ConstructorDefinition>;
    /** @deprecated Create a TypeInstance and use addSubtype(TypeInstance) */
    addSubtype_dep(qualifiedTypeName: PossiblyQualifiedName): void;
    addSubtype(typeInstance: TypeInstance): void;
    addConstructor(parameters: KtList<ParameterDeclaration>): void;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.DataType": unique symbol;
    } & StructuredType["__doNotUseOrImplementIt"];
}
export declare interface UnionType extends TypeDefinition {
    readonly alternatives: KtList<TypeInstance>;
    addAlternative(value: TypeInstance): void;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): UnionType;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.UnionType": unique symbol;
    } & TypeDefinition["__doNotUseOrImplementIt"];
}
export declare interface CollectionType extends StructuredType {
    readonly isStdList: boolean;
    readonly isStdSet: boolean;
    readonly isStdMap: boolean;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.CollectionType": unique symbol;
    } & StructuredType["__doNotUseOrImplementIt"];
}
export declare class PropertyName implements PublicValueType {
    constructor(value: string);
    get value(): string;
    toString(): string;
    copy(value?: string): PropertyName;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyName.$metadata$ {
    const constructor: abstract new () => PropertyName;
}
export declare interface PropertyDeclaration {
    readonly owner: TypeDefinition;
    readonly name: PropertyName;
    readonly typeInstance: TypeInstance;
    readonly characteristics: KtSet<PropertyCharacteristic>;
    readonly description: string;
    readonly opposite: KtList<PropertyDeclaration>;
    readonly index: number;
    readonly metaInfo: KtMap<string, string>;
    readonly isReference: boolean;
    readonly isComposite: boolean;
    readonly isConstructor: boolean;
    readonly isIdentity: boolean;
    readonly isReadOnly: boolean;
    readonly isReadWrite: boolean;
    readonly isStored: boolean;
    readonly isDerived: boolean;
    readonly isPrimitive: boolean;
    readonly execution: Nullable<(p0: any) => Nullable<any>>;
    readonly executionSuspend: Nullable<any /*Suspend functions are not supported*/>;
    resolved(typeArguments: KtMap<TypeParameter, TypeInstance>): PropertyDeclarationResolved;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): PropertyDeclaration;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.PropertyDeclaration": unique symbol;
    };
}
export declare interface PropertyDeclarationResolved extends PropertyDeclaration {
    readonly original: PropertyDeclaration;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.PropertyDeclarationResolved": unique symbol;
    } & PropertyDeclaration["__doNotUseOrImplementIt"];
}
export declare abstract class PropertyCharacteristic {
    private constructor();
    static get REFERENCE(): PropertyCharacteristic & {
        get name(): "REFERENCE";
        get ordinal(): 0;
    };
    static get COMPOSITE(): PropertyCharacteristic & {
        get name(): "COMPOSITE";
        get ordinal(): 1;
    };
    static get READ_ONLY(): PropertyCharacteristic & {
        get name(): "READ_ONLY";
        get ordinal(): 2;
    };
    static get READ_WRITE(): PropertyCharacteristic & {
        get name(): "READ_WRITE";
        get ordinal(): 3;
    };
    static get STORED(): PropertyCharacteristic & {
        get name(): "STORED";
        get ordinal(): 4;
    };
    static get DERIVED(): PropertyCharacteristic & {
        get name(): "DERIVED";
        get ordinal(): 5;
    };
    static get PRIMITIVE(): PropertyCharacteristic & {
        get name(): "PRIMITIVE";
        get ordinal(): 6;
    };
    static get CONSTRUCTOR(): PropertyCharacteristic & {
        get name(): "CONSTRUCTOR";
        get ordinal(): 7;
    };
    static get IDENTITY(): PropertyCharacteristic & {
        get name(): "IDENTITY";
        get ordinal(): 8;
    };
    get name(): "REFERENCE" | "COMPOSITE" | "READ_ONLY" | "READ_WRITE" | "STORED" | "DERIVED" | "PRIMITIVE" | "CONSTRUCTOR" | "IDENTITY";
    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
    asString(indent?: Indent): string;
    static values(): Array<PropertyCharacteristic>;
    static valueOf(value: string): PropertyCharacteristic;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PropertyCharacteristic.$metadata$ {
    const constructor: abstract new () => PropertyCharacteristic;
}
export declare class MethodName implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): MethodName;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MethodName.$metadata$ {
    const constructor: abstract new () => MethodName;
}
export declare interface MethodDefinition {
    readonly owner: TypeDefinition;
    readonly name: MethodName;
    readonly parameters: KtList<ParameterDeclaration>;
    readonly returnType: TypeInstance;
    readonly description: string;
    readonly execution: Nullable<(p0: any, p1: KtList<any /*UnknownType **/>) => Nullable<any>>;
    readonly executionSuspend: Nullable<any /*Suspend functions are not supported*/>;
    resolved(typeArguments: KtMap<TypeParameter, TypeInstance>): MethodDefinitionResolved;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): MethodDefinition;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.MethodDefinition": unique symbol;
    };
}
export declare interface MethodDefinitionPrimitive extends MethodDefinition {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.MethodDefinitionPrimitive": unique symbol;
    } & MethodDefinition["__doNotUseOrImplementIt"];
}
export declare interface MethodDefinitionDerived extends MethodDefinition {
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.MethodDefinitionDerived": unique symbol;
    } & MethodDefinition["__doNotUseOrImplementIt"];
}
export declare interface MethodDefinitionResolved extends MethodDefinition {
    readonly original: MethodDefinition;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.MethodDefinitionResolved": unique symbol;
    } & MethodDefinition["__doNotUseOrImplementIt"];
}
export declare interface ConstructorDefinition {
    readonly owner: TypeDefinition;
    readonly parameters: KtList<ParameterDeclaration>;
    readonly execution: Nullable<(p0: KtList<any /*UnknownType **/>) => Nullable<any>>;
    readonly executionSuspend: Nullable<any /*Suspend functions are not supported*/>;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ConstructorDefinition;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.ConstructorDefinition": unique symbol;
    };
}
export declare class TmParameterName implements PublicValueType {
    constructor(value: string);
    get value(): string;
    copy(value?: string): TmParameterName;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
    readonly __doNotUseOrImplementIt: PublicValueType["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TmParameterName.$metadata$ {
    const constructor: abstract new () => TmParameterName;
}
export declare interface ParameterDeclaration {
    readonly name: TmParameterName;
    readonly typeInstance: TypeInstance;
    readonly defaultValue: Nullable<string>;
    findInOrCloneTo(other: Domain<TypesNamespace, TypeDefinition>/* TypesDomain */): ParameterDeclaration;
    readonly __doNotUseOrImplementIt: {
        readonly "net.akehurst.language.types.api.ParameterDeclaration": unique symbol;
    };
}
export declare function typesDomain(name: string, resolveImports: boolean, namespaces: KtList<TypesNamespace> | undefined, init: (p0: TypeDomainBuilder) => void): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
export declare class TypeDomainBuilder {
    constructor(name: SimpleName, resolveImports: boolean, namespaces: KtList<TypesNamespace>);
    get name(): SimpleName;
    get namespaces(): KtList<TypesNamespace>;
    get _domain(): Domain<TypesNamespace, TypeDefinition>/* TypesDomainSimple */;
    namespace(qualifiedName: string, imports: KtList<string> | undefined, init: (p0: any/* TypeNamespaceBuilder */) => void): TypesNamespace;
    build(): Domain<TypesNamespace, TypeDefinition>/* TypesDomain */;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeDomainBuilder.$metadata$ {
    const constructor: abstract new () => TypeDomainBuilder;
}
export declare class AssociationBuilder {
    constructor(_namespace: TypesNamespace, _typeReferences: KtMutableList<TypeInstanceArgBuilder>);
    protected get _namespace(): TypesNamespace;
    protected get _typeReferences(): KtMutableList<TypeInstanceArgBuilder>;
    get CMP(): PropertyCharacteristic;
    get REF(): PropertyCharacteristic;
    get VAL(): PropertyCharacteristic;
    get VAR(): PropertyCharacteristic;
    end(possiblyQualifiedTypeName: string, characteristics: KtSet<PropertyCharacteristic>, endName: string, isNullable?: boolean, collectionTypeName?: Nullable<string>, byEvaluation?: Nullable<(p0: PropertyDeclaration) => Nullable<(p0: any) => Nullable<any>>>): void;
    endSuspend(possiblyQualifiedTypeName: string, characteristics: KtSet<PropertyCharacteristic>, endName: string, isNullable?: boolean, collectionTypeName?: Nullable<string>, byEvaluation?: Nullable<(p0: PropertyDeclaration) => Nullable<any /*Suspend functions are not supported*/>>): void;
    build(): KtList<PropertyDeclaration>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace AssociationBuilder.$metadata$ {
    const constructor: abstract new () => AssociationBuilder;
}
export declare namespace AssociationBuilder {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        namespace type {
            class AssocEnd {
                constructor(endTypeName: string, characteristics: KtSet<PropertyCharacteristic>, endName: string, isNullable: boolean, collectionTypeName: Nullable<string>, byEvaluation?: Nullable<(p0: PropertyDeclaration) => Nullable<(p0: any) => Nullable<any>>>, byEvaluationSuspend?: Nullable<(p0: PropertyDeclaration) => Nullable<any /*Suspend functions are not supported*/>>);
                get endTypeName(): string;
                get characteristics(): KtSet<PropertyCharacteristic>;
                get endName(): string;
                get isNullable(): boolean;
                get collectionTypeName(): Nullable<string>;
                get byEvaluation(): Nullable<(p0: PropertyDeclaration) => Nullable<(p0: any) => Nullable<any>>>;
                get byEvaluationSuspend(): Nullable<(p0: PropertyDeclaration) => Nullable<any /*Suspend functions are not supported*/>>;
                copy(endTypeName?: string, characteristics?: KtSet<PropertyCharacteristic>, endName?: string, isNullable?: boolean, collectionTypeName?: Nullable<string>, byEvaluation?: Nullable<(p0: PropertyDeclaration) => Nullable<(p0: any) => Nullable<any>>>, byEvaluationSuspend?: Nullable<(p0: PropertyDeclaration) => Nullable<any /*Suspend functions are not supported*/>>): AssociationBuilder.Companion.AssocEnd;
                toString(): string;
                hashCode(): number;
                equals(other: Nullable<any>): boolean;
            }
            /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
            namespace AssocEnd.$metadata$ {
                const constructor: abstract new () => AssocEnd;
            }
        }
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class PrimitiveTypeBuilder {
    constructor(_namespace: TypesNamespace, _typeReferences: KtMutableList<TypeInstanceArgBuilder>, _name: SimpleName);
    supertype(typeDeclarationName: string, init?: (p0: TypeInstanceArgBuilder) => void): void;
    constructor_(init: (p0: any/* ConstructorBuilder */) => void): void;
    derivedPropertyOf(propertyName: string, typeName: string, isNullable?: boolean, execution?: Nullable<(p0: Nullable<any>) => Nullable<any>>, init?: (p0: TypeArgumentBuilder) => void): PropertyDeclaration;
    derivedPropertyOfSuspend(propertyName: string, typeName: string, isNullable?: boolean, execution?: Nullable<any /*Suspend functions are not supported*/>, init?: (p0: TypeArgumentBuilder) => void): PropertyDeclaration;
    methodPrimitive(methodName: string, returnTypeName: string, isNullable?: boolean, init?: (p0: any/* MethodParameterBuilder */) => void): MethodDefinitionPrimitive;
    methodPrimitiveSuspend(methodName: string, returnTypeName: string, isNullable?: boolean, init?: (p0: any/* MethodParameterBuilder */) => void): MethodDefinitionPrimitive;
    build(): PrimitiveType;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace PrimitiveTypeBuilder.$metadata$ {
    const constructor: abstract new () => PrimitiveTypeBuilder;
}
export declare class EnumTypeBuilder {
    constructor(_namespace: TypesNamespace, _name: SimpleName, _literals: KtList<string>);
    build(): EnumType;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EnumTypeBuilder.$metadata$ {
    const constructor: abstract new () => EnumTypeBuilder;
}
export declare class TypeInstanceArgBuilder {
    constructor(context: Nullable<TypeDefinition>, _namespace: TypesNamespace, possiblyQualifiedName: PossiblyQualifiedName, nullable: boolean, _typeReferences: KtMutableList<TypeInstanceArgBuilder>);
    get context(): Nullable<TypeDefinition>;
    get _namespace(): TypesNamespace;
    get possiblyQualifiedName(): PossiblyQualifiedName;
    get nullable(): boolean;
    protected get _typeReferences(): KtMutableList<TypeInstanceArgBuilder>;
    ref(possiblyQualifiedTypeDeclarationName: string, init?: (p0: TypeInstanceArgBuilder) => void): void;
    build(): TypeInstance;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeInstanceArgBuilder.$metadata$ {
    const constructor: abstract new () => TypeInstanceArgBuilder;
}
export declare class TypeInstanceArgNamedBuilder {
    constructor(context: Nullable<TypeDefinition>, _namespace: TypesNamespace, type: TypeDefinition, instanceIsNullable: boolean, _typeReferences: KtMutableList<TypeInstanceArgBuilder>);
    get context(): Nullable<TypeDefinition>;
    get _namespace(): TypesNamespace;
    get type(): TypeDefinition;
    get instanceIsNullable(): boolean;
    protected get _typeReferences(): KtMutableList<TypeInstanceArgBuilder>;
    typeRef(name: string, typeName: string, isNullable: boolean): void;
    tupleType(name: string, isNullable: boolean, init: (p0: TypeInstanceArgNamedBuilder) => void): void;
    build(): TypeInstance;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeInstanceArgNamedBuilder.$metadata$ {
    const constructor: abstract new () => TypeInstanceArgNamedBuilder;
}
export declare class TypeArgumentBuilder {
    constructor(_context: Nullable<TypeDefinition>, _namespace: TypesNamespace);
    typeArgument(possiblyQualifiedTypeDeclarationName: string, nullable?: boolean, typeArguments?: (p0: TypeArgumentBuilder) => void): void;
    build(): KtList<TypeArgument>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TypeArgumentBuilder.$metadata$ {
    const constructor: abstract new () => TypeArgumentBuilder;
}
export declare class SubtypeListBuilder {
    constructor(_namespace: TypesNamespace, _typeReferences: KtMutableList<TypeInstanceArgBuilder>);
    get _namespace(): TypesNamespace;
    get _subtypeList(): KtMutableList<TypeInstance>;
    typeRef(typeName: string, isNullable?: boolean): void;
    listType(isNullable: boolean | undefined, init: (p0: TypeInstanceArgBuilder) => void): void;
    listSeparatedType(isNullable: boolean | undefined, init: (p0: TypeInstanceArgBuilder) => void): void;
    tupleType(isNullable: boolean | undefined, init: (p0: TypeInstanceArgNamedBuilder) => void): void;
    build(): KtList<TypeInstance>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SubtypeListBuilder.$metadata$ {
    const constructor: abstract new () => SubtypeListBuilder;
}