net.akehurst.language-agl-processor
Version:
12,513 lines • 690 kB
text/typescript
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;
}