@zenstackhq/language 3.5.6 → 3.6.0

package/dist/ast-W2h6Qtfk.d.cts

@@ -0,0 +1,525 @@
+import * as langium from "langium";
+import { AstNode, AstNode as AstNode$1, Reference as Reference$1 } from "langium";
+
+//#region src/generated/ast.d.ts
+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" | "Undefined" | "Unsupported" | "Void" | "[" | "]" | "^" | "_" | "abstract" | "attribute" | "datasource" | "enum" | "extends" | "false" | "function" | "generator" | "import" | "in" | "model" | "mutation" | "null" | "plugin" | "procedure" | "this" | "true" | "type" | "view" | "with" | "{" | "||" | "}";
+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' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Undefined' | 'Unsupported' | 'Void';
+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 = DataField;
+declare const MemberAccessTarget = "MemberAccessTarget";
+declare function isMemberAccessTarget(item: unknown): item is MemberAccessTarget;
+type ReferenceTarget = CollectionPredicateBinding | DataField | EnumField | FunctionParam;
+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' | 'Void' | 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;
+interface Argument extends langium.AstNode {
+  readonly $container: InvocationExpr;
+  readonly $type: 'Argument';
+  value: Expression;
+}
+declare const Argument = "Argument";
+declare function isArgument(item: unknown): item is Argument;
+interface ArrayExpr extends langium.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 langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'Attribute';
+  attributes: Array<InternalAttribute>;
+  comments: Array<string>;
+  name: string;
+  params: Array<AttributeParam>;
+}
+declare const Attribute = "Attribute";
+declare function isAttribute(item: unknown): item is Attribute;
+interface AttributeArg extends langium.AstNode {
+  readonly $container: DataFieldAttribute | DataModelAttribute | InternalAttribute;
+  readonly $type: 'AttributeArg';
+  name?: RegularID;
+  value: Expression;
+  /** Resolved attribute param declaration */
+  $resolvedParam?: AttributeParam;
+}
+declare const AttributeArg = "AttributeArg";
+declare function isAttributeArg(item: unknown): item is AttributeArg;
+interface AttributeParam extends langium.AstNode {
+  readonly $container: Attribute;
+  readonly $type: 'AttributeParam';
+  attributes: Array<InternalAttribute>;
+  comments: Array<string>;
+  default: boolean;
+  name: RegularID;
+  type: AttributeParamType;
+}
+declare const AttributeParam = "AttributeParam";
+declare function isAttributeParam(item: unknown): item is AttributeParam;
+interface AttributeParamType extends langium.AstNode {
+  readonly $container: AttributeParam;
+  readonly $type: 'AttributeParamType';
+  array: boolean;
+  optional: boolean;
+  reference?: langium.Reference<TypeDeclaration>;
+  type?: 'ContextType' | 'FieldReference' | 'TransitiveFieldReference' | ExpressionType;
+}
+declare const AttributeParamType = "AttributeParamType";
+declare function isAttributeParamType(item: unknown): item is AttributeParamType;
+interface BinaryExpr extends langium.AstNode {
+  readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+  readonly $type: 'BinaryExpr';
+  binding?: CollectionPredicateBinding;
+  left: Expression;
+  operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | 'in' | '||';
+  right: Expression;
+}
+declare const BinaryExpr = "BinaryExpr";
+declare function isBinaryExpr(item: unknown): item is BinaryExpr;
+interface BooleanLiteral extends langium.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 CollectionPredicateBinding extends langium.AstNode {
+  readonly $container: BinaryExpr;
+  readonly $type: 'CollectionPredicateBinding';
+  name: RegularID;
+}
+declare const CollectionPredicateBinding = "CollectionPredicateBinding";
+declare function isCollectionPredicateBinding(item: unknown): item is CollectionPredicateBinding;
+interface ConfigArrayExpr extends langium.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 langium.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 langium.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 langium.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 DataField extends langium.AstNode {
+  readonly $container: DataModel | TypeDef;
+  readonly $type: 'DataField';
+  attributes: Array<DataFieldAttribute>;
+  comments: Array<string>;
+  name: RegularIDWithTypeNames;
+  type: DataFieldType;
+}
+declare const DataField = "DataField";
+declare function isDataField(item: unknown): item is DataField;
+interface DataFieldAttribute extends langium.AstNode {
+  readonly $container: DataField | EnumField;
+  readonly $type: 'DataFieldAttribute';
+  args: Array<AttributeArg>;
+  decl: langium.Reference<Attribute>;
+}
+declare const DataFieldAttribute = "DataFieldAttribute";
+declare function isDataFieldAttribute(item: unknown): item is DataFieldAttribute;
+interface DataFieldType extends langium.AstNode {
+  readonly $container: DataField;
+  readonly $type: 'DataFieldType';
+  array: boolean;
+  optional: boolean;
+  reference?: langium.Reference<TypeDeclaration>;
+  type?: BuiltinType;
+  unsupported?: UnsupportedFieldType;
+}
+declare const DataFieldType = "DataFieldType";
+declare function isDataFieldType(item: unknown): item is DataFieldType;
+interface DataModel extends langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'DataModel';
+  attributes: Array<DataModelAttribute>;
+  baseModel?: langium.Reference<DataModel>;
+  comments: Array<string>;
+  fields: Array<DataField>;
+  isView: boolean;
+  mixins: Array<langium.Reference<TypeDef>>;
+  name: RegularID;
+  /** All fields including those marked with `@ignore` */
+  $allFields?: DataField[];
+}
+declare const DataModel = "DataModel";
+declare function isDataModel(item: unknown): item is DataModel;
+interface DataModelAttribute extends langium.AstNode {
+  readonly $container: DataModel | Enum | TypeDef;
+  readonly $type: 'DataModelAttribute';
+  args: Array<AttributeArg>;
+  decl: langium.Reference<Attribute>;
+}
+declare const DataModelAttribute = "DataModelAttribute";
+declare function isDataModelAttribute(item: unknown): item is DataModelAttribute;
+interface DataSource extends langium.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 langium.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 langium.AstNode {
+  readonly $container: Enum;
+  readonly $type: 'EnumField';
+  attributes: Array<DataFieldAttribute>;
+  comments: Array<string>;
+  name: RegularIDWithTypeNames;
+}
+declare const EnumField = "EnumField";
+declare function isEnumField(item: unknown): item is EnumField;
+interface FieldInitializer extends langium.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 langium.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 langium.AstNode {
+  readonly $container: FunctionDecl;
+  readonly $type: 'FunctionParam';
+  name: RegularID;
+  optional: boolean;
+  type: FunctionParamType;
+}
+declare const FunctionParam = "FunctionParam";
+declare function isFunctionParam(item: unknown): item is FunctionParam;
+interface FunctionParamType extends langium.AstNode {
+  readonly $container: FunctionDecl | FunctionParam | Procedure | ProcedureParam;
+  readonly $type: 'FunctionParamType';
+  array: boolean;
+  reference?: langium.Reference<TypeDeclaration>;
+  type?: ExpressionType;
+}
+declare const FunctionParamType = "FunctionParamType";
+declare function isFunctionParamType(item: unknown): item is FunctionParamType;
+interface GeneratorDecl extends langium.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 langium.AstNode {
+  readonly $container: Attribute | AttributeParam | FunctionDecl | Procedure;
+  readonly $type: 'InternalAttribute';
+  args: Array<AttributeArg>;
+  decl: langium.Reference<Attribute>;
+}
+declare const InternalAttribute = "InternalAttribute";
+declare function isInternalAttribute(item: unknown): item is InternalAttribute;
+interface InvocationExpr extends langium.AstNode {
+  readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigField | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+  readonly $type: 'InvocationExpr';
+  args: Array<Argument>;
+  function: langium.Reference<FunctionDecl>;
+}
+declare const InvocationExpr = "InvocationExpr";
+declare function isInvocationExpr(item: unknown): item is InvocationExpr;
+interface MemberAccessExpr extends langium.AstNode {
+  readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+  readonly $type: 'MemberAccessExpr';
+  member: langium.Reference<MemberAccessTarget>;
+  operand: Expression;
+}
+declare const MemberAccessExpr = "MemberAccessExpr";
+declare function isMemberAccessExpr(item: unknown): item is MemberAccessExpr;
+interface Model extends langium.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 langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'ModelImport';
+  path: string;
+}
+declare const ModelImport = "ModelImport";
+declare function isModelImport(item: unknown): item is ModelImport;
+interface NullExpr extends langium.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 langium.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 langium.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 langium.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 langium.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 langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'Procedure';
+  attributes: Array<InternalAttribute>;
+  mutation: boolean;
+  name: RegularID;
+  params: Array<ProcedureParam>;
+  returnType: FunctionParamType;
+}
+declare const Procedure = "Procedure";
+declare function isProcedure(item: unknown): item is Procedure;
+interface ProcedureParam extends langium.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 langium.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 langium.AstNode {
+  readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
+  readonly $type: 'ReferenceExpr';
+  args: Array<ReferenceArg>;
+  target: langium.Reference<ReferenceTarget>;
+}
+declare const ReferenceExpr = "ReferenceExpr";
+declare function isReferenceExpr(item: unknown): item is ReferenceExpr;
+interface StringLiteral extends langium.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 langium.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 langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'TypeDef';
+  attributes: Array<DataModelAttribute>;
+  comments: Array<string>;
+  fields: Array<DataField>;
+  mixins: Array<langium.Reference<TypeDef>>;
+  name: RegularID;
+}
+declare const TypeDef = "TypeDef";
+declare function isTypeDef(item: unknown): item is TypeDef;
+interface UnaryExpr extends langium.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 langium.AstNode {
+  readonly $container: DataFieldType;
+  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;
+  AttributeParamType: AttributeParamType;
+  BinaryExpr: BinaryExpr;
+  BooleanLiteral: BooleanLiteral;
+  CollectionPredicateBinding: CollectionPredicateBinding;
+  ConfigArrayExpr: ConfigArrayExpr;
+  ConfigExpr: ConfigExpr;
+  ConfigField: ConfigField;
+  ConfigInvocationArg: ConfigInvocationArg;
+  ConfigInvocationExpr: ConfigInvocationExpr;
+  DataField: DataField;
+  DataFieldAttribute: DataFieldAttribute;
+  DataFieldType: DataFieldType;
+  DataModel: DataModel;
+  DataModelAttribute: DataModelAttribute;
+  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;
+  UnaryExpr: UnaryExpr;
+  UnsupportedFieldType: UnsupportedFieldType;
+};
+declare class ZModelAstReflection extends langium.AbstractAstReflection {
+  getAllTypes(): string[];
+  protected computeIsSubtype(subtype: string, supertype: string): boolean;
+  getReferenceType(refInfo: langium.ReferenceInfo): string;
+  getTypeMetaData(type: string): langium.TypeMetaData;
+}
+declare const reflection: ZModelAstReflection;
+//#endregion
+//#region src/ast.d.ts
+/**
+ * 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>;
+interface InheritableNode extends AstNode {
+  $inheritedFrom?: DataModel;
+}
+declare module 'langium' {
+  interface AstNode {
+    /**
+     * Resolved type information attached to expressions
+     */
+    $resolvedType?: ResolvedType;
+  }
+}
+//#endregion
+export { ReferenceArg as $, isModel as $t, Enum as A, isConfigField as At, InvocationExpr as B, isEnumField as Bt, ConfigInvocationExpr as C, isBinaryExpr as Ct, DataModel as D, isCollectionPredicateBinding as Dt, DataFieldType as E, isBuiltinType as Et, FunctionDecl as F, isDataFieldType as Ft, ModelImport as G, isFunctionParam as Gt, MemberAccessExpr as H, isExpressionType as Ht, FunctionParam as I, isDataModel as It, ObjectExpr as J, isInternalAttribute as Jt, NullExpr as K, isFunctionParamType as Kt, FunctionParamType as L, isDataModelAttribute as Lt, Expression as M, isConfigInvocationExpr as Mt, ExpressionType as N, isDataField as Nt, DataModelAttribute as O, isConfigArrayExpr as Ot, FieldInitializer as P, isDataFieldAttribute as Pt, ProcedureParam as Q, isMemberAccessTarget as Qt, GeneratorDecl as R, isDataSource as Rt, ConfigInvocationArg as S, isAttributeParamType as St, DataFieldAttribute as T, isBooleanLiteral as Tt, MemberAccessTarget as U, isFieldInitializer as Ut, LiteralExpr as V, isExpression as Vt, Model as W, isFunctionDecl as Wt, PluginField as X, isLiteralExpr as Xt, Plugin as Y, isInvocationExpr as Yt, Procedure as Z, isMemberAccessExpr as Zt, BuiltinType as _, isUnaryExpr as _n, isArgument as _t, ResolvedShape as a, isPluginField as an, ThisExpr as at, ConfigExpr as b, isAttributeArg as bt, Argument as c, isReferenceArg as cn, UnaryExpr as ct, AttributeArg as d, isRegularID as dn, ZModelAstType as dt, isModelImport as en, ReferenceExpr as et, AttributeParam as f, isRegularIDWithTypeNames as fn, ZModelKeywordNames as ft, BooleanLiteral as g, isTypeDef as gn, isAbstractDeclaration as gt, Boolean as h, isTypeDeclaration as hn, ZModelTokenNames as ht, Reference$1 as i, isPlugin as in, StringLiteral as it, EnumField as j, isConfigInvocationArg as jt, DataSource as k, isConfigExpr as kt, ArrayExpr as l, isReferenceExpr as ln, UnsupportedFieldType as lt, BinaryExpr as m, isThisExpr as mn, ZModelTerminals as mt, BinaryExprOperatorPriority as n, isNumberLiteral as nn, RegularID as nt, ResolvedType as o, isProcedure as on, TypeDeclaration as ot, AttributeParamType as p, isStringLiteral as pn, ZModelTerminalNames as pt, NumberLiteral as q, isGeneratorDecl as qt, InheritableNode as r, isObjectExpr as rn, RegularIDWithTypeNames as rt, AbstractDeclaration as s, isProcedureParam as sn, TypeDef as st, AstNode$1 as t, isNullExpr as tn, ReferenceTarget as tt, Attribute as u, isReferenceTarget as un, ZModelAstReflection as ut, CollectionPredicateBinding as v, isUnsupportedFieldType as vn, isArrayExpr as vt, DataField as w, isBoolean as wt, ConfigField as x, isAttributeParam as xt, ConfigArrayExpr as y, reflection as yn, isAttribute as yt, InternalAttribute as z, isEnum as zt };
+//# sourceMappingURL=ast-W2h6Qtfk.d.cts.map