@zenstackhq/language 2.16.0 → 3.0.0-alpha.0

package/dist/ast.d.ts

@@ -0,0 +1,566 @@
+import { AstNode, Reference, AbstractAstReflection, ReferenceInfo, TypeMetaData } from 'langium';
+export { AstNode, Reference } from 'langium';
+
+/******************************************************************************
+ * This file was generated by langium-cli 3.3.0.
+ * DO NOT EDIT MANUALLY!
+ ******************************************************************************/
+
+declare const ZModelTerminals: {
+    WS: RegExp;
+    INTERNAL_ATTRIBUTE_NAME: RegExp;
+    MODEL_ATTRIBUTE_NAME: RegExp;
+    FIELD_ATTRIBUTE_NAME: RegExp;
+    ID: RegExp;
+    STRING: RegExp;
+    NUMBER: RegExp;
+    TRIPLE_SLASH_COMMENT: RegExp;
+    ML_COMMENT: RegExp;
+    SL_COMMENT: RegExp;
+};
+type ZModelTerminalNames = keyof typeof ZModelTerminals;
+type ZModelKeywordNames = "!" | "!=" | "&&" | "(" | ")" | "," | "." | ":" | ";" | "<" | "<=" | "=" | "==" | ">" | ">=" | "?" | "Any" | "BigInt" | "Boolean" | "Bytes" | "ContextType" | "DateTime" | "Decimal" | "FieldReference" | "Float" | "Int" | "Json" | "Null" | "Object" | "String" | "TransitiveFieldReference" | "Unsupported" | "[" | "]" | "^" | "_" | "abstract" | "attribute" | "datasource" | "enum" | "extends" | "false" | "function" | "generator" | "import" | "in" | "model" | "mutation" | "null" | "plugin" | "procedure" | "this" | "true" | "type" | "view" | "{" | "||" | "}";
+type ZModelTokenNames = ZModelTerminalNames | ZModelKeywordNames;
+type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | FunctionDecl | GeneratorDecl | Plugin | Procedure | TypeDef;
+declare const AbstractDeclaration = "AbstractDeclaration";
+declare function isAbstractDeclaration(item: unknown): item is AbstractDeclaration;
+type Boolean = boolean;
+declare function isBoolean(item: unknown): item is Boolean;
+type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String';
+declare function isBuiltinType(item: unknown): item is BuiltinType;
+type ConfigExpr = ConfigArrayExpr | InvocationExpr | LiteralExpr;
+declare const ConfigExpr = "ConfigExpr";
+declare function isConfigExpr(item: unknown): item is ConfigExpr;
+type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ObjectExpr | ReferenceExpr | ThisExpr | UnaryExpr;
+declare const Expression = "Expression";
+declare function isExpression(item: unknown): item is Expression;
+type ExpressionType = 'Any' | 'Boolean' | 'DateTime' | 'Float' | 'Int' | 'Null' | 'Object' | 'String' | 'Unsupported';
+declare function isExpressionType(item: unknown): item is ExpressionType;
+type LiteralExpr = BooleanLiteral | NumberLiteral | StringLiteral;
+declare const LiteralExpr = "LiteralExpr";
+declare function isLiteralExpr(item: unknown): item is LiteralExpr;
+type MemberAccessTarget = DataModelField | TypeDefField;
+declare const MemberAccessTarget = "MemberAccessTarget";
+declare function isMemberAccessTarget(item: unknown): item is MemberAccessTarget;
+type ReferenceTarget = DataModelField | EnumField | FunctionParam | TypeDefField;
+declare const ReferenceTarget = "ReferenceTarget";
+declare function isReferenceTarget(item: unknown): item is ReferenceTarget;
+type RegularID = 'abstract' | 'attribute' | 'datasource' | 'enum' | 'import' | 'in' | 'model' | 'plugin' | 'type' | 'view' | string;
+declare function isRegularID(item: unknown): item is RegularID;
+type RegularIDWithTypeNames = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Unsupported' | RegularID;
+declare function isRegularIDWithTypeNames(item: unknown): item is RegularIDWithTypeNames;
+type TypeDeclaration = DataModel | Enum | TypeDef;
+declare const TypeDeclaration = "TypeDeclaration";
+declare function isTypeDeclaration(item: unknown): item is TypeDeclaration;
+type TypeDefFieldTypes = Enum | TypeDef;
+declare const TypeDefFieldTypes = "TypeDefFieldTypes";
+declare function isTypeDefFieldTypes(item: unknown): item is TypeDefFieldTypes;
+interface Argument extends AstNode {
+    readonly $container: InvocationExpr;
+    readonly $type: 'Argument';
+    value: Expression;
+}
+declare const Argument = "Argument";
+declare function isArgument(item: unknown): item is Argument;
+interface ArrayExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr;
+    readonly $type: 'ArrayExpr';
+    items: Array<Expression>;
+}
+declare const ArrayExpr = "ArrayExpr";
+declare function isArrayExpr(item: unknown): item is ArrayExpr;
+interface Attribute extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'Attribute';
+    attributes: Array<InternalAttribute>;
+    comments: Array<string>;
+    name: string;
+    params: Array<AttributeParam$1>;
+}
+declare const Attribute = "Attribute";
+declare function isAttribute(item: unknown): item is Attribute;
+interface AttributeArg extends AstNode {
+    readonly $container: DataModelAttribute | DataModelFieldAttribute | InternalAttribute;
+    readonly $type: 'AttributeArg';
+    name?: RegularID;
+    value: Expression;
+}
+declare const AttributeArg = "AttributeArg";
+declare function isAttributeArg(item: unknown): item is AttributeArg;
+interface AttributeParam$1 extends AstNode {
+    readonly $container: Attribute;
+    readonly $type: 'AttributeParam';
+    attributes: Array<InternalAttribute>;
+    comments: Array<string>;
+    default: boolean;
+    name: RegularID;
+    type: AttributeParamType;
+}
+declare const AttributeParam$1 = "AttributeParam";
+declare function isAttributeParam(item: unknown): item is AttributeParam$1;
+interface AttributeParamType extends AstNode {
+    readonly $container: AttributeParam$1;
+    readonly $type: 'AttributeParamType';
+    array: boolean;
+    optional: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: 'ContextType' | 'FieldReference' | 'TransitiveFieldReference' | ExpressionType;
+}
+declare const AttributeParamType = "AttributeParamType";
+declare function isAttributeParamType(item: unknown): item is AttributeParamType;
+interface BinaryExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'BinaryExpr';
+    left: Expression;
+    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | 'in' | '||';
+    right: Expression;
+}
+declare const BinaryExpr = "BinaryExpr";
+declare function isBinaryExpr(item: unknown): item is BinaryExpr;
+interface BooleanLiteral extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigArrayExpr | ConfigField | ConfigInvocationArg | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr | UnsupportedFieldType;
+    readonly $type: 'BooleanLiteral';
+    value: Boolean;
+}
+declare const BooleanLiteral = "BooleanLiteral";
+declare function isBooleanLiteral(item: unknown): item is BooleanLiteral;
+interface ConfigArrayExpr extends AstNode {
+    readonly $container: ConfigField;
+    readonly $type: 'ConfigArrayExpr';
+    items: Array<ConfigInvocationExpr | LiteralExpr>;
+}
+declare const ConfigArrayExpr = "ConfigArrayExpr";
+declare function isConfigArrayExpr(item: unknown): item is ConfigArrayExpr;
+interface ConfigField extends AstNode {
+    readonly $container: DataSource | GeneratorDecl;
+    readonly $type: 'ConfigField';
+    name: RegularID;
+    value: ConfigExpr;
+}
+declare const ConfigField = "ConfigField";
+declare function isConfigField(item: unknown): item is ConfigField;
+interface ConfigInvocationArg extends AstNode {
+    readonly $container: ConfigInvocationExpr;
+    readonly $type: 'ConfigInvocationArg';
+    name: string;
+    value: LiteralExpr;
+}
+declare const ConfigInvocationArg = "ConfigInvocationArg";
+declare function isConfigInvocationArg(item: unknown): item is ConfigInvocationArg;
+interface ConfigInvocationExpr extends AstNode {
+    readonly $container: ConfigArrayExpr;
+    readonly $type: 'ConfigInvocationExpr';
+    args: Array<ConfigInvocationArg>;
+    name: string;
+}
+declare const ConfigInvocationExpr = "ConfigInvocationExpr";
+declare function isConfigInvocationExpr(item: unknown): item is ConfigInvocationExpr;
+interface DataModel extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'DataModel';
+    attributes: Array<DataModelAttribute>;
+    comments: Array<string>;
+    fields: Array<DataModelField>;
+    isAbstract: boolean;
+    isView: boolean;
+    name: RegularID;
+    superTypes: Array<Reference<DataModel>>;
+}
+declare const DataModel = "DataModel";
+declare function isDataModel(item: unknown): item is DataModel;
+interface DataModelAttribute extends AstNode {
+    readonly $container: DataModel | Enum | TypeDef;
+    readonly $type: 'DataModelAttribute';
+    args: Array<AttributeArg>;
+    decl: Reference<Attribute>;
+}
+declare const DataModelAttribute = "DataModelAttribute";
+declare function isDataModelAttribute(item: unknown): item is DataModelAttribute;
+interface DataModelField extends AstNode {
+    readonly $container: DataModel;
+    readonly $type: 'DataModelField';
+    attributes: Array<DataModelFieldAttribute>;
+    comments: Array<string>;
+    name: RegularIDWithTypeNames;
+    type: DataModelFieldType;
+}
+declare const DataModelField = "DataModelField";
+declare function isDataModelField(item: unknown): item is DataModelField;
+interface DataModelFieldAttribute extends AstNode {
+    readonly $container: DataModelField | EnumField | TypeDefField;
+    readonly $type: 'DataModelFieldAttribute';
+    args: Array<AttributeArg>;
+    decl: Reference<Attribute>;
+}
+declare const DataModelFieldAttribute = "DataModelFieldAttribute";
+declare function isDataModelFieldAttribute(item: unknown): item is DataModelFieldAttribute;
+interface DataModelFieldType extends AstNode {
+    readonly $container: DataModelField;
+    readonly $type: 'DataModelFieldType';
+    array: boolean;
+    optional: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: BuiltinType;
+    unsupported?: UnsupportedFieldType;
+}
+declare const DataModelFieldType = "DataModelFieldType";
+declare function isDataModelFieldType(item: unknown): item is DataModelFieldType;
+interface DataSource extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'DataSource';
+    fields: Array<ConfigField>;
+    name: RegularID;
+}
+declare const DataSource = "DataSource";
+declare function isDataSource(item: unknown): item is DataSource;
+interface Enum extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'Enum';
+    attributes: Array<DataModelAttribute>;
+    comments: Array<string>;
+    fields: Array<EnumField>;
+    name: RegularID;
+}
+declare const Enum = "Enum";
+declare function isEnum(item: unknown): item is Enum;
+interface EnumField extends AstNode {
+    readonly $container: Enum;
+    readonly $type: 'EnumField';
+    attributes: Array<DataModelFieldAttribute>;
+    comments: Array<string>;
+    name: RegularIDWithTypeNames;
+}
+declare const EnumField = "EnumField";
+declare function isEnumField(item: unknown): item is EnumField;
+interface FieldInitializer extends AstNode {
+    readonly $container: ObjectExpr;
+    readonly $type: 'FieldInitializer';
+    name: RegularID | string;
+    value: Expression;
+}
+declare const FieldInitializer = "FieldInitializer";
+declare function isFieldInitializer(item: unknown): item is FieldInitializer;
+interface FunctionDecl extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'FunctionDecl';
+    attributes: Array<InternalAttribute>;
+    expression?: Expression;
+    name: RegularID;
+    params: Array<FunctionParam>;
+    returnType: FunctionParamType;
+}
+declare const FunctionDecl = "FunctionDecl";
+declare function isFunctionDecl(item: unknown): item is FunctionDecl;
+interface FunctionParam extends AstNode {
+    readonly $container: FunctionDecl | Procedure;
+    readonly $type: 'FunctionParam';
+    name: RegularID;
+    optional: boolean;
+    type: FunctionParamType;
+}
+declare const FunctionParam = "FunctionParam";
+declare function isFunctionParam(item: unknown): item is FunctionParam;
+interface FunctionParamType extends AstNode {
+    readonly $container: FunctionDecl | FunctionParam | Procedure | ProcedureParam;
+    readonly $type: 'FunctionParamType';
+    array: boolean;
+    reference?: Reference<TypeDeclaration>;
+    type?: ExpressionType;
+}
+declare const FunctionParamType = "FunctionParamType";
+declare function isFunctionParamType(item: unknown): item is FunctionParamType;
+interface GeneratorDecl extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'GeneratorDecl';
+    fields: Array<ConfigField>;
+    name: RegularID;
+}
+declare const GeneratorDecl = "GeneratorDecl";
+declare function isGeneratorDecl(item: unknown): item is GeneratorDecl;
+interface InternalAttribute extends AstNode {
+    readonly $container: Attribute | AttributeParam$1 | FunctionDecl | Procedure;
+    readonly $type: 'InternalAttribute';
+    args: Array<AttributeArg>;
+    decl: Reference<Attribute>;
+}
+declare const InternalAttribute = "InternalAttribute";
+declare function isInternalAttribute(item: unknown): item is InternalAttribute;
+interface InvocationExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigField | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'InvocationExpr';
+    args: Array<Argument>;
+    function: Reference<FunctionDecl>;
+}
+declare const InvocationExpr = "InvocationExpr";
+declare function isInvocationExpr(item: unknown): item is InvocationExpr;
+interface MemberAccessExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'MemberAccessExpr';
+    member: Reference<MemberAccessTarget>;
+    operand: Expression;
+}
+declare const MemberAccessExpr = "MemberAccessExpr";
+declare function isMemberAccessExpr(item: unknown): item is MemberAccessExpr;
+interface Model extends AstNode {
+    readonly $type: 'Model';
+    declarations: Array<AbstractDeclaration>;
+    imports: Array<ModelImport>;
+}
+declare const Model = "Model";
+declare function isModel(item: unknown): item is Model;
+interface ModelImport extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'ModelImport';
+    path: string;
+}
+declare const ModelImport = "ModelImport";
+declare function isModelImport(item: unknown): item is ModelImport;
+interface NullExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'NullExpr';
+    value: 'null';
+}
+declare const NullExpr = "NullExpr";
+declare function isNullExpr(item: unknown): item is NullExpr;
+interface NumberLiteral extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigArrayExpr | ConfigField | ConfigInvocationArg | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr | UnsupportedFieldType;
+    readonly $type: 'NumberLiteral';
+    value: string;
+}
+declare const NumberLiteral = "NumberLiteral";
+declare function isNumberLiteral(item: unknown): item is NumberLiteral;
+interface ObjectExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr;
+    readonly $type: 'ObjectExpr';
+    fields: Array<FieldInitializer>;
+}
+declare const ObjectExpr = "ObjectExpr";
+declare function isObjectExpr(item: unknown): item is ObjectExpr;
+interface Plugin extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'Plugin';
+    fields: Array<PluginField>;
+    name: RegularID;
+}
+declare const Plugin = "Plugin";
+declare function isPlugin(item: unknown): item is Plugin;
+interface PluginField extends AstNode {
+    readonly $container: Plugin;
+    readonly $type: 'PluginField';
+    name: RegularID;
+    value: ArrayExpr | LiteralExpr | ObjectExpr;
+}
+declare const PluginField = "PluginField";
+declare function isPluginField(item: unknown): item is PluginField;
+interface Procedure extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'Procedure';
+    attributes: Array<InternalAttribute>;
+    mutation: boolean;
+    name: RegularID;
+    params: Array<FunctionParam | ProcedureParam>;
+    returnType: FunctionParamType;
+}
+declare const Procedure = "Procedure";
+declare function isProcedure(item: unknown): item is Procedure;
+interface ProcedureParam extends AstNode {
+    readonly $container: Procedure;
+    readonly $type: 'ProcedureParam';
+    name: RegularID;
+    optional: boolean;
+    type: FunctionParamType;
+}
+declare const ProcedureParam = "ProcedureParam";
+declare function isProcedureParam(item: unknown): item is ProcedureParam;
+interface ReferenceArg extends AstNode {
+    readonly $container: ReferenceExpr;
+    readonly $type: 'ReferenceArg';
+    name: string;
+    value: Expression;
+}
+declare const ReferenceArg = "ReferenceArg";
+declare function isReferenceArg(item: unknown): item is ReferenceArg;
+interface ReferenceExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'ReferenceExpr';
+    args: Array<ReferenceArg>;
+    target: Reference<ReferenceTarget>;
+}
+declare const ReferenceExpr = "ReferenceExpr";
+declare function isReferenceExpr(item: unknown): item is ReferenceExpr;
+interface StringLiteral extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigArrayExpr | ConfigField | ConfigInvocationArg | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr | UnsupportedFieldType;
+    readonly $type: 'StringLiteral';
+    value: string;
+}
+declare const StringLiteral = "StringLiteral";
+declare function isStringLiteral(item: unknown): item is StringLiteral;
+interface ThisExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'ThisExpr';
+    value: 'this';
+}
+declare const ThisExpr = "ThisExpr";
+declare function isThisExpr(item: unknown): item is ThisExpr;
+interface TypeDef extends AstNode {
+    readonly $container: Model;
+    readonly $type: 'TypeDef';
+    attributes: Array<DataModelAttribute>;
+    comments: Array<string>;
+    fields: Array<TypeDefField>;
+    name: RegularID;
+}
+declare const TypeDef = "TypeDef";
+declare function isTypeDef(item: unknown): item is TypeDef;
+interface TypeDefField extends AstNode {
+    readonly $container: TypeDef;
+    readonly $type: 'TypeDefField';
+    attributes: Array<DataModelFieldAttribute>;
+    comments: Array<string>;
+    name: RegularIDWithTypeNames;
+    type: TypeDefFieldType;
+}
+declare const TypeDefField = "TypeDefField";
+declare function isTypeDefField(item: unknown): item is TypeDefField;
+interface TypeDefFieldType extends AstNode {
+    readonly $container: TypeDefField;
+    readonly $type: 'TypeDefFieldType';
+    array: boolean;
+    optional: boolean;
+    reference?: Reference<TypeDefFieldTypes>;
+    type?: BuiltinType;
+}
+declare const TypeDefFieldType = "TypeDefFieldType";
+declare function isTypeDefFieldType(item: unknown): item is TypeDefFieldType;
+interface UnaryExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+    readonly $type: 'UnaryExpr';
+    operand: Expression;
+    operator: '!';
+}
+declare const UnaryExpr = "UnaryExpr";
+declare function isUnaryExpr(item: unknown): item is UnaryExpr;
+interface UnsupportedFieldType extends AstNode {
+    readonly $container: DataModelFieldType;
+    readonly $type: 'UnsupportedFieldType';
+    value: LiteralExpr;
+}
+declare const UnsupportedFieldType = "UnsupportedFieldType";
+declare function isUnsupportedFieldType(item: unknown): item is UnsupportedFieldType;
+type ZModelAstType = {
+    AbstractDeclaration: AbstractDeclaration;
+    Argument: Argument;
+    ArrayExpr: ArrayExpr;
+    Attribute: Attribute;
+    AttributeArg: AttributeArg;
+    AttributeParam: AttributeParam$1;
+    AttributeParamType: AttributeParamType;
+    BinaryExpr: BinaryExpr;
+    BooleanLiteral: BooleanLiteral;
+    ConfigArrayExpr: ConfigArrayExpr;
+    ConfigExpr: ConfigExpr;
+    ConfigField: ConfigField;
+    ConfigInvocationArg: ConfigInvocationArg;
+    ConfigInvocationExpr: ConfigInvocationExpr;
+    DataModel: DataModel;
+    DataModelAttribute: DataModelAttribute;
+    DataModelField: DataModelField;
+    DataModelFieldAttribute: DataModelFieldAttribute;
+    DataModelFieldType: DataModelFieldType;
+    DataSource: DataSource;
+    Enum: Enum;
+    EnumField: EnumField;
+    Expression: Expression;
+    FieldInitializer: FieldInitializer;
+    FunctionDecl: FunctionDecl;
+    FunctionParam: FunctionParam;
+    FunctionParamType: FunctionParamType;
+    GeneratorDecl: GeneratorDecl;
+    InternalAttribute: InternalAttribute;
+    InvocationExpr: InvocationExpr;
+    LiteralExpr: LiteralExpr;
+    MemberAccessExpr: MemberAccessExpr;
+    MemberAccessTarget: MemberAccessTarget;
+    Model: Model;
+    ModelImport: ModelImport;
+    NullExpr: NullExpr;
+    NumberLiteral: NumberLiteral;
+    ObjectExpr: ObjectExpr;
+    Plugin: Plugin;
+    PluginField: PluginField;
+    Procedure: Procedure;
+    ProcedureParam: ProcedureParam;
+    ReferenceArg: ReferenceArg;
+    ReferenceExpr: ReferenceExpr;
+    ReferenceTarget: ReferenceTarget;
+    StringLiteral: StringLiteral;
+    ThisExpr: ThisExpr;
+    TypeDeclaration: TypeDeclaration;
+    TypeDef: TypeDef;
+    TypeDefField: TypeDefField;
+    TypeDefFieldType: TypeDefFieldType;
+    TypeDefFieldTypes: TypeDefFieldTypes;
+    UnaryExpr: UnaryExpr;
+    UnsupportedFieldType: UnsupportedFieldType;
+};
+declare class ZModelAstReflection extends AbstractAstReflection {
+    getAllTypes(): string[];
+    protected computeIsSubtype(subtype: string, supertype: string): boolean;
+    getReferenceType(refInfo: ReferenceInfo): string;
+    getTypeMetaData(type: string): TypeMetaData;
+}
+declare const reflection: ZModelAstReflection;
+
+/**
+ * Shape of type resolution result: an expression type or reference to a declaration
+ */
+type ResolvedShape = ExpressionType | AbstractDeclaration;
+/**
+ * Resolved type information (attached to expressions by linker)
+ */
+type ResolvedType = {
+    decl?: ResolvedShape;
+    array?: boolean;
+    nullable?: boolean;
+};
+declare const BinaryExprOperatorPriority: Record<BinaryExpr['operator'], number>;
+declare module './ast' {
+    interface AttributeArg {
+        /**
+         * Resolved attribute param declaration
+         */
+        $resolvedParam?: AttributeParam;
+    }
+    interface DataModelField {
+        $inheritedFrom?: DataModel;
+    }
+    interface DataModelAttribute {
+        $inheritedFrom?: DataModel;
+    }
+    interface DataModel {
+        /**
+         * Indicates whether the model is already merged with the base types
+         */
+        $baseMerged?: boolean;
+        /**
+         * All fields including those marked with `@ignore`
+         */
+        $allFields?: DataModelField[];
+    }
+}
+interface InheritableNode extends AstNode {
+    $inheritedFrom?: DataModel;
+}
+interface InheritableNode extends AstNode {
+    $inheritedFrom?: DataModel;
+}
+declare module 'langium' {
+    interface AstNode {
+        /**
+         * Resolved type information attached to expressions
+         */
+        $resolvedType?: ResolvedType;
+    }
+}
+
+export { AbstractDeclaration, Argument, ArrayExpr, Attribute, AttributeArg, AttributeParam$1 as AttributeParam, AttributeParamType, BinaryExpr, BinaryExprOperatorPriority, type Boolean, BooleanLiteral, type BuiltinType, ConfigArrayExpr, ConfigExpr, ConfigField, ConfigInvocationArg, ConfigInvocationExpr, DataModel, DataModelAttribute, DataModelField, DataModelFieldAttribute, DataModelFieldType, DataSource, Enum, EnumField, Expression, type ExpressionType, FieldInitializer, FunctionDecl, FunctionParam, FunctionParamType, GeneratorDecl, type InheritableNode, InternalAttribute, InvocationExpr, LiteralExpr, MemberAccessExpr, MemberAccessTarget, Model, ModelImport, NullExpr, NumberLiteral, ObjectExpr, Plugin, PluginField, Procedure, ProcedureParam, ReferenceArg, ReferenceExpr, ReferenceTarget, type RegularID, type RegularIDWithTypeNames, type ResolvedShape, type ResolvedType, StringLiteral, ThisExpr, TypeDeclaration, TypeDef, TypeDefField, TypeDefFieldType, TypeDefFieldTypes, UnaryExpr, UnsupportedFieldType, ZModelAstReflection, type ZModelAstType, type ZModelKeywordNames, type ZModelTerminalNames, ZModelTerminals, type ZModelTokenNames, isAbstractDeclaration, isArgument, isArrayExpr, isAttribute, isAttributeArg, isAttributeParam, isAttributeParamType, isBinaryExpr, isBoolean, isBooleanLiteral, isBuiltinType, isConfigArrayExpr, isConfigExpr, isConfigField, isConfigInvocationArg, isConfigInvocationExpr, isDataModel, isDataModelAttribute, isDataModelField, isDataModelFieldAttribute, isDataModelFieldType, isDataSource, isEnum, isEnumField, isExpression, isExpressionType, isFieldInitializer, isFunctionDecl, isFunctionParam, isFunctionParamType, isGeneratorDecl, isInternalAttribute, isInvocationExpr, isLiteralExpr, isMemberAccessExpr, isMemberAccessTarget, isModel, isModelImport, isNullExpr, isNumberLiteral, isObjectExpr, isPlugin, isPluginField, isProcedure, isProcedureParam, isReferenceArg, isReferenceExpr, isReferenceTarget, isRegularID, isRegularIDWithTypeNames, isStringLiteral, isThisExpr, isTypeDeclaration, isTypeDef, isTypeDefField, isTypeDefFieldType, isTypeDefFieldTypes, isUnaryExpr, isUnsupportedFieldType, reflection };