@zenstackhq/language 3.8.0-beta.1 → 3.8.0-beta.3

package/dist/ast-DhPyAQoX.d.mts

@@ -0,0 +1,1440 @@
+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: {
+  readonly $type: "AbstractDeclaration";
+};
+declare function isAbstractDeclaration(item: unknown): item is AbstractDeclaration;
+interface Argument extends langium.AstNode {
+  readonly $container: InvocationExpr;
+  readonly $type: 'Argument';
+  value: Expression;
+}
+declare const Argument: {
+  readonly $type: "Argument";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "ArrayExpr";
+  readonly items: "items";
+};
+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: {
+  readonly $type: "Attribute";
+  readonly attributes: "attributes";
+  readonly comments: "comments";
+  readonly name: "name";
+  readonly params: "params";
+};
+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: {
+  readonly $type: "AttributeArg";
+  readonly name: "name";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "AttributeParam";
+  readonly attributes: "attributes";
+  readonly comments: "comments";
+  readonly default: "default";
+  readonly name: "name";
+  readonly type: "type";
+};
+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: {
+  readonly $type: "AttributeParamType";
+  readonly array: "array";
+  readonly optional: "optional";
+  readonly reference: "reference";
+  readonly type: "type";
+};
+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: {
+  readonly $type: "BinaryExpr";
+  readonly binding: "binding";
+  readonly left: "left";
+  readonly operator: "operator";
+  readonly right: "right";
+};
+declare function isBinaryExpr(item: unknown): item is BinaryExpr;
+type Boolean = boolean;
+declare function isBoolean(item: unknown): item is Boolean;
+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: {
+  readonly $type: "BooleanLiteral";
+  readonly value: "value";
+};
+declare function isBooleanLiteral(item: unknown): item is BooleanLiteral;
+type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String';
+declare function isBuiltinType(item: unknown): item is BuiltinType;
+interface CollectionPredicateBinding extends langium.AstNode {
+  readonly $container: BinaryExpr;
+  readonly $type: 'CollectionPredicateBinding';
+  name: RegularID;
+}
+declare const CollectionPredicateBinding: {
+  readonly $type: "CollectionPredicateBinding";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "ConfigArrayExpr";
+  readonly items: "items";
+};
+declare function isConfigArrayExpr(item: unknown): item is ConfigArrayExpr;
+type ConfigExpr = ConfigArrayExpr | InvocationExpr | LiteralExpr;
+declare const ConfigExpr: {
+  readonly $type: "ConfigExpr";
+};
+declare function isConfigExpr(item: unknown): item is ConfigExpr;
+interface ConfigField extends langium.AstNode {
+  readonly $container: DataSource | GeneratorDecl;
+  readonly $type: 'ConfigField';
+  name: RegularID;
+  value: ConfigExpr;
+}
+declare const ConfigField: {
+  readonly $type: "ConfigField";
+  readonly name: "name";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "ConfigInvocationArg";
+  readonly name: "name";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "ConfigInvocationExpr";
+  readonly args: "args";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "DataField";
+  readonly attributes: "attributes";
+  readonly comments: "comments";
+  readonly name: "name";
+  readonly type: "type";
+};
+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: {
+  readonly $type: "DataFieldAttribute";
+  readonly args: "args";
+  readonly decl: "decl";
+};
+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: {
+  readonly $type: "DataFieldType";
+  readonly array: "array";
+  readonly optional: "optional";
+  readonly reference: "reference";
+  readonly type: "type";
+  readonly unsupported: "unsupported";
+};
+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: {
+  readonly $type: "DataModel";
+  readonly attributes: "attributes";
+  readonly baseModel: "baseModel";
+  readonly comments: "comments";
+  readonly fields: "fields";
+  readonly isView: "isView";
+  readonly mixins: "mixins";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "DataModelAttribute";
+  readonly args: "args";
+  readonly decl: "decl";
+};
+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: {
+  readonly $type: "DataSource";
+  readonly fields: "fields";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "Enum";
+  readonly attributes: "attributes";
+  readonly comments: "comments";
+  readonly fields: "fields";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "EnumField";
+  readonly attributes: "attributes";
+  readonly comments: "comments";
+  readonly name: "name";
+};
+declare function isEnumField(item: unknown): item is EnumField;
+type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ObjectExpr | ReferenceExpr | ThisExpr | UnaryExpr;
+declare const Expression: {
+  readonly $type: "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;
+interface FieldInitializer extends langium.AstNode {
+  readonly $container: ObjectExpr;
+  readonly $type: 'FieldInitializer';
+  name: RegularID | string;
+  value: Expression;
+}
+declare const FieldInitializer: {
+  readonly $type: "FieldInitializer";
+  readonly name: "name";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "FunctionDecl";
+  readonly attributes: "attributes";
+  readonly expression: "expression";
+  readonly name: "name";
+  readonly params: "params";
+  readonly returnType: "returnType";
+};
+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: {
+  readonly $type: "FunctionParam";
+  readonly name: "name";
+  readonly optional: "optional";
+  readonly type: "type";
+};
+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: {
+  readonly $type: "FunctionParamType";
+  readonly array: "array";
+  readonly reference: "reference";
+  readonly type: "type";
+};
+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: {
+  readonly $type: "GeneratorDecl";
+  readonly fields: "fields";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "InternalAttribute";
+  readonly args: "args";
+  readonly decl: "decl";
+};
+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: {
+  readonly $type: "InvocationExpr";
+  readonly args: "args";
+  readonly function: "function";
+};
+declare function isInvocationExpr(item: unknown): item is InvocationExpr;
+type LiteralExpr = BooleanLiteral | NumberLiteral | StringLiteral;
+declare const LiteralExpr: {
+  readonly $type: "LiteralExpr";
+};
+declare function isLiteralExpr(item: unknown): item is LiteralExpr;
+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: {
+  readonly $type: "MemberAccessExpr";
+  readonly member: "member";
+  readonly operand: "operand";
+};
+declare function isMemberAccessExpr(item: unknown): item is MemberAccessExpr;
+type MemberAccessTarget = DataField;
+declare const MemberAccessTarget: {
+  readonly $type: "MemberAccessTarget";
+};
+declare function isMemberAccessTarget(item: unknown): item is MemberAccessTarget;
+interface Model extends langium.AstNode {
+  readonly $type: 'Model';
+  declarations: Array<AbstractDeclaration>;
+  imports: Array<ModelImport>;
+}
+declare const Model: {
+  readonly $type: "Model";
+  readonly declarations: "declarations";
+  readonly imports: "imports";
+};
+declare function isModel(item: unknown): item is Model;
+interface ModelImport extends langium.AstNode {
+  readonly $container: Model;
+  readonly $type: 'ModelImport';
+  path: string;
+}
+declare const ModelImport: {
+  readonly $type: "ModelImport";
+  readonly path: "path";
+};
+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: {
+  readonly $type: "NullExpr";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "NumberLiteral";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "ObjectExpr";
+  readonly fields: "fields";
+};
+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: {
+  readonly $type: "Plugin";
+  readonly fields: "fields";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "PluginField";
+  readonly name: "name";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "Procedure";
+  readonly attributes: "attributes";
+  readonly mutation: "mutation";
+  readonly name: "name";
+  readonly params: "params";
+  readonly returnType: "returnType";
+};
+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: {
+  readonly $type: "ProcedureParam";
+  readonly name: "name";
+  readonly optional: "optional";
+  readonly type: "type";
+};
+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: {
+  readonly $type: "ReferenceArg";
+  readonly name: "name";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "ReferenceExpr";
+  readonly args: "args";
+  readonly target: "target";
+};
+declare function isReferenceExpr(item: unknown): item is ReferenceExpr;
+type ReferenceTarget = CollectionPredicateBinding | DataField | EnumField | FunctionParam;
+declare const ReferenceTarget: {
+  readonly $type: "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;
+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: {
+  readonly $type: "StringLiteral";
+  readonly value: "value";
+};
+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: {
+  readonly $type: "ThisExpr";
+  readonly value: "value";
+};
+declare function isThisExpr(item: unknown): item is ThisExpr;
+type TypeDeclaration = DataModel | Enum | TypeDef;
+declare const TypeDeclaration: {
+  readonly $type: "TypeDeclaration";
+};
+declare function isTypeDeclaration(item: unknown): item is TypeDeclaration;
+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: {
+  readonly $type: "TypeDef";
+  readonly attributes: "attributes";
+  readonly comments: "comments";
+  readonly fields: "fields";
+  readonly mixins: "mixins";
+  readonly name: "name";
+};
+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: {
+  readonly $type: "UnaryExpr";
+  readonly operand: "operand";
+  readonly operator: "operator";
+};
+declare function isUnaryExpr(item: unknown): item is UnaryExpr;
+interface UnsupportedFieldType extends langium.AstNode {
+  readonly $container: DataFieldType;
+  readonly $type: 'UnsupportedFieldType';
+  value: LiteralExpr;
+}
+declare const UnsupportedFieldType: {
+  readonly $type: "UnsupportedFieldType";
+  readonly value: "value";
+};
+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 {
+  readonly types: {
+    readonly AbstractDeclaration: {
+      readonly name: "AbstractDeclaration";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly Argument: {
+      readonly name: "Argument";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ArrayExpr: {
+      readonly name: "ArrayExpr";
+      readonly properties: {
+        readonly items: {
+          readonly name: "items";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly Attribute: {
+      readonly name: "Attribute";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly params: {
+          readonly name: "params";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration"];
+    };
+    readonly AttributeArg: {
+      readonly name: "AttributeArg";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly AttributeParam: {
+      readonly name: "AttributeParam";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly default: {
+          readonly name: "default";
+          readonly defaultValue: false;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly AttributeParamType: {
+      readonly name: "AttributeParamType";
+      readonly properties: {
+        readonly array: {
+          readonly name: "array";
+          readonly defaultValue: false;
+        };
+        readonly optional: {
+          readonly name: "optional";
+          readonly defaultValue: false;
+        };
+        readonly reference: {
+          readonly name: "reference";
+          readonly referenceType: "TypeDeclaration";
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly BinaryExpr: {
+      readonly name: "BinaryExpr";
+      readonly properties: {
+        readonly binding: {
+          readonly name: "binding";
+        };
+        readonly left: {
+          readonly name: "left";
+        };
+        readonly operator: {
+          readonly name: "operator";
+        };
+        readonly right: {
+          readonly name: "right";
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly BooleanLiteral: {
+      readonly name: "BooleanLiteral";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["LiteralExpr"];
+    };
+    readonly CollectionPredicateBinding: {
+      readonly name: "CollectionPredicateBinding";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["ReferenceTarget"];
+    };
+    readonly ConfigArrayExpr: {
+      readonly name: "ConfigArrayExpr";
+      readonly properties: {
+        readonly items: {
+          readonly name: "items";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: ["ConfigExpr"];
+    };
+    readonly ConfigExpr: {
+      readonly name: "ConfigExpr";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly ConfigField: {
+      readonly name: "ConfigField";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ConfigInvocationArg: {
+      readonly name: "ConfigInvocationArg";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ConfigInvocationExpr: {
+      readonly name: "ConfigInvocationExpr";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly DataField: {
+      readonly name: "DataField";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+      };
+      readonly superTypes: ["MemberAccessTarget", "ReferenceTarget"];
+    };
+    readonly DataFieldAttribute: {
+      readonly name: "DataFieldAttribute";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+        readonly decl: {
+          readonly name: "decl";
+          readonly referenceType: "Attribute";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly DataFieldType: {
+      readonly name: "DataFieldType";
+      readonly properties: {
+        readonly array: {
+          readonly name: "array";
+          readonly defaultValue: false;
+        };
+        readonly optional: {
+          readonly name: "optional";
+          readonly defaultValue: false;
+        };
+        readonly reference: {
+          readonly name: "reference";
+          readonly referenceType: "TypeDeclaration";
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+        readonly unsupported: {
+          readonly name: "unsupported";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly DataModel: {
+      readonly name: "DataModel";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly baseModel: {
+          readonly name: "baseModel";
+          readonly referenceType: "DataModel";
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+        readonly isView: {
+          readonly name: "isView";
+          readonly defaultValue: false;
+        };
+        readonly mixins: {
+          readonly name: "mixins";
+          readonly defaultValue: [];
+          readonly referenceType: "TypeDef";
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration", "TypeDeclaration"];
+    };
+    readonly DataModelAttribute: {
+      readonly name: "DataModelAttribute";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+        readonly decl: {
+          readonly name: "decl";
+          readonly referenceType: "Attribute";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly DataSource: {
+      readonly name: "DataSource";
+      readonly properties: {
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration"];
+    };
+    readonly Enum: {
+      readonly name: "Enum";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration", "TypeDeclaration"];
+    };
+    readonly EnumField: {
+      readonly name: "EnumField";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["ReferenceTarget"];
+    };
+    readonly Expression: {
+      readonly name: "Expression";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly FieldInitializer: {
+      readonly name: "FieldInitializer";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly FunctionDecl: {
+      readonly name: "FunctionDecl";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly expression: {
+          readonly name: "expression";
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly params: {
+          readonly name: "params";
+          readonly defaultValue: [];
+        };
+        readonly returnType: {
+          readonly name: "returnType";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration"];
+    };
+    readonly FunctionParam: {
+      readonly name: "FunctionParam";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly optional: {
+          readonly name: "optional";
+          readonly defaultValue: false;
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+      };
+      readonly superTypes: ["ReferenceTarget"];
+    };
+    readonly FunctionParamType: {
+      readonly name: "FunctionParamType";
+      readonly properties: {
+        readonly array: {
+          readonly name: "array";
+          readonly defaultValue: false;
+        };
+        readonly reference: {
+          readonly name: "reference";
+          readonly referenceType: "TypeDeclaration";
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly GeneratorDecl: {
+      readonly name: "GeneratorDecl";
+      readonly properties: {
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration"];
+    };
+    readonly InternalAttribute: {
+      readonly name: "InternalAttribute";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+        readonly decl: {
+          readonly name: "decl";
+          readonly referenceType: "Attribute";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly InvocationExpr: {
+      readonly name: "InvocationExpr";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+        readonly function: {
+          readonly name: "function";
+          readonly referenceType: "FunctionDecl";
+        };
+      };
+      readonly superTypes: ["ConfigExpr", "Expression"];
+    };
+    readonly LiteralExpr: {
+      readonly name: "LiteralExpr";
+      readonly properties: {};
+      readonly superTypes: ["ConfigExpr", "Expression"];
+    };
+    readonly MemberAccessExpr: {
+      readonly name: "MemberAccessExpr";
+      readonly properties: {
+        readonly member: {
+          readonly name: "member";
+          readonly referenceType: "MemberAccessTarget";
+        };
+        readonly operand: {
+          readonly name: "operand";
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly MemberAccessTarget: {
+      readonly name: "MemberAccessTarget";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly Model: {
+      readonly name: "Model";
+      readonly properties: {
+        readonly declarations: {
+          readonly name: "declarations";
+          readonly defaultValue: [];
+        };
+        readonly imports: {
+          readonly name: "imports";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ModelImport: {
+      readonly name: "ModelImport";
+      readonly properties: {
+        readonly path: {
+          readonly name: "path";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly NullExpr: {
+      readonly name: "NullExpr";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly NumberLiteral: {
+      readonly name: "NumberLiteral";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["LiteralExpr"];
+    };
+    readonly ObjectExpr: {
+      readonly name: "ObjectExpr";
+      readonly properties: {
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly Plugin: {
+      readonly name: "Plugin";
+      readonly properties: {
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration"];
+    };
+    readonly PluginField: {
+      readonly name: "PluginField";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly Procedure: {
+      readonly name: "Procedure";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly mutation: {
+          readonly name: "mutation";
+          readonly defaultValue: false;
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly params: {
+          readonly name: "params";
+          readonly defaultValue: [];
+        };
+        readonly returnType: {
+          readonly name: "returnType";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration"];
+    };
+    readonly ProcedureParam: {
+      readonly name: "ProcedureParam";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly optional: {
+          readonly name: "optional";
+          readonly defaultValue: false;
+        };
+        readonly type: {
+          readonly name: "type";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ReferenceArg: {
+      readonly name: "ReferenceArg";
+      readonly properties: {
+        readonly name: {
+          readonly name: "name";
+        };
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+    readonly ReferenceExpr: {
+      readonly name: "ReferenceExpr";
+      readonly properties: {
+        readonly args: {
+          readonly name: "args";
+          readonly defaultValue: [];
+        };
+        readonly target: {
+          readonly name: "target";
+          readonly referenceType: "ReferenceTarget";
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly ReferenceTarget: {
+      readonly name: "ReferenceTarget";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly StringLiteral: {
+      readonly name: "StringLiteral";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["LiteralExpr"];
+    };
+    readonly ThisExpr: {
+      readonly name: "ThisExpr";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly TypeDeclaration: {
+      readonly name: "TypeDeclaration";
+      readonly properties: {};
+      readonly superTypes: [];
+    };
+    readonly TypeDef: {
+      readonly name: "TypeDef";
+      readonly properties: {
+        readonly attributes: {
+          readonly name: "attributes";
+          readonly defaultValue: [];
+        };
+        readonly comments: {
+          readonly name: "comments";
+          readonly defaultValue: [];
+        };
+        readonly fields: {
+          readonly name: "fields";
+          readonly defaultValue: [];
+        };
+        readonly mixins: {
+          readonly name: "mixins";
+          readonly defaultValue: [];
+          readonly referenceType: "TypeDef";
+        };
+        readonly name: {
+          readonly name: "name";
+        };
+      };
+      readonly superTypes: ["AbstractDeclaration", "TypeDeclaration"];
+    };
+    readonly UnaryExpr: {
+      readonly name: "UnaryExpr";
+      readonly properties: {
+        readonly operand: {
+          readonly name: "operand";
+        };
+        readonly operator: {
+          readonly name: "operator";
+        };
+      };
+      readonly superTypes: ["Expression"];
+    };
+    readonly UnsupportedFieldType: {
+      readonly name: "UnsupportedFieldType";
+      readonly properties: {
+        readonly value: {
+          readonly name: "value";
+        };
+      };
+      readonly superTypes: [];
+    };
+  };
+}
+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-DhPyAQoX.d.mts.map