@zenstackhq/language 2.16.0 → 3.0.0-alpha.0

package/dist/ast.js

@@ -0,0 +1,1331 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/generated/ast.ts
+import { AbstractAstReflection } from "langium";
+var ZModelTerminals = {
+  WS: /\s+/,
+  INTERNAL_ATTRIBUTE_NAME: /@@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
+  MODEL_ATTRIBUTE_NAME: /@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
+  FIELD_ATTRIBUTE_NAME: /@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
+  ID: /[_a-zA-Z][\w_]*/,
+  STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+  NUMBER: /[+-]?[0-9]+(\.[0-9]+)?/,
+  TRIPLE_SLASH_COMMENT: /\/\/\/[^\n\r]*/,
+  ML_COMMENT: /\/\*[\s\S]*?\*\//,
+  SL_COMMENT: /\/\/[^\n\r]*/
+};
+var AbstractDeclaration = "AbstractDeclaration";
+function isAbstractDeclaration(item) {
+  return reflection.isInstance(item, AbstractDeclaration);
+}
+__name(isAbstractDeclaration, "isAbstractDeclaration");
+function isBoolean(item) {
+  return typeof item === "boolean";
+}
+__name(isBoolean, "isBoolean");
+function isBuiltinType(item) {
+  return item === "String" || item === "Boolean" || item === "Int" || item === "BigInt" || item === "Float" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes";
+}
+__name(isBuiltinType, "isBuiltinType");
+var ConfigExpr = "ConfigExpr";
+function isConfigExpr(item) {
+  return reflection.isInstance(item, ConfigExpr);
+}
+__name(isConfigExpr, "isConfigExpr");
+var Expression = "Expression";
+function isExpression(item) {
+  return reflection.isInstance(item, Expression);
+}
+__name(isExpression, "isExpression");
+function isExpressionType(item) {
+  return item === "String" || item === "Int" || item === "Float" || item === "Boolean" || item === "DateTime" || item === "Null" || item === "Object" || item === "Any" || item === "Unsupported";
+}
+__name(isExpressionType, "isExpressionType");
+var LiteralExpr = "LiteralExpr";
+function isLiteralExpr(item) {
+  return reflection.isInstance(item, LiteralExpr);
+}
+__name(isLiteralExpr, "isLiteralExpr");
+var MemberAccessTarget = "MemberAccessTarget";
+function isMemberAccessTarget(item) {
+  return reflection.isInstance(item, MemberAccessTarget);
+}
+__name(isMemberAccessTarget, "isMemberAccessTarget");
+var ReferenceTarget = "ReferenceTarget";
+function isReferenceTarget(item) {
+  return reflection.isInstance(item, ReferenceTarget);
+}
+__name(isReferenceTarget, "isReferenceTarget");
+function isRegularID(item) {
+  return item === "model" || item === "enum" || item === "attribute" || item === "datasource" || item === "plugin" || item === "abstract" || item === "in" || item === "view" || item === "import" || item === "type" || typeof item === "string" && /[_a-zA-Z][\w_]*/.test(item);
+}
+__name(isRegularID, "isRegularID");
+function isRegularIDWithTypeNames(item) {
+  return isRegularID(item) || item === "String" || item === "Boolean" || item === "Int" || item === "BigInt" || item === "Float" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes" || item === "Null" || item === "Object" || item === "Any" || item === "Unsupported";
+}
+__name(isRegularIDWithTypeNames, "isRegularIDWithTypeNames");
+var TypeDeclaration = "TypeDeclaration";
+function isTypeDeclaration(item) {
+  return reflection.isInstance(item, TypeDeclaration);
+}
+__name(isTypeDeclaration, "isTypeDeclaration");
+var TypeDefFieldTypes = "TypeDefFieldTypes";
+function isTypeDefFieldTypes(item) {
+  return reflection.isInstance(item, TypeDefFieldTypes);
+}
+__name(isTypeDefFieldTypes, "isTypeDefFieldTypes");
+var Argument = "Argument";
+function isArgument(item) {
+  return reflection.isInstance(item, Argument);
+}
+__name(isArgument, "isArgument");
+var ArrayExpr = "ArrayExpr";
+function isArrayExpr(item) {
+  return reflection.isInstance(item, ArrayExpr);
+}
+__name(isArrayExpr, "isArrayExpr");
+var Attribute = "Attribute";
+function isAttribute(item) {
+  return reflection.isInstance(item, Attribute);
+}
+__name(isAttribute, "isAttribute");
+var AttributeArg = "AttributeArg";
+function isAttributeArg(item) {
+  return reflection.isInstance(item, AttributeArg);
+}
+__name(isAttributeArg, "isAttributeArg");
+var AttributeParam = "AttributeParam";
+function isAttributeParam(item) {
+  return reflection.isInstance(item, AttributeParam);
+}
+__name(isAttributeParam, "isAttributeParam");
+var AttributeParamType = "AttributeParamType";
+function isAttributeParamType(item) {
+  return reflection.isInstance(item, AttributeParamType);
+}
+__name(isAttributeParamType, "isAttributeParamType");
+var BinaryExpr = "BinaryExpr";
+function isBinaryExpr(item) {
+  return reflection.isInstance(item, BinaryExpr);
+}
+__name(isBinaryExpr, "isBinaryExpr");
+var BooleanLiteral = "BooleanLiteral";
+function isBooleanLiteral(item) {
+  return reflection.isInstance(item, BooleanLiteral);
+}
+__name(isBooleanLiteral, "isBooleanLiteral");
+var ConfigArrayExpr = "ConfigArrayExpr";
+function isConfigArrayExpr(item) {
+  return reflection.isInstance(item, ConfigArrayExpr);
+}
+__name(isConfigArrayExpr, "isConfigArrayExpr");
+var ConfigField = "ConfigField";
+function isConfigField(item) {
+  return reflection.isInstance(item, ConfigField);
+}
+__name(isConfigField, "isConfigField");
+var ConfigInvocationArg = "ConfigInvocationArg";
+function isConfigInvocationArg(item) {
+  return reflection.isInstance(item, ConfigInvocationArg);
+}
+__name(isConfigInvocationArg, "isConfigInvocationArg");
+var ConfigInvocationExpr = "ConfigInvocationExpr";
+function isConfigInvocationExpr(item) {
+  return reflection.isInstance(item, ConfigInvocationExpr);
+}
+__name(isConfigInvocationExpr, "isConfigInvocationExpr");
+var DataModel = "DataModel";
+function isDataModel(item) {
+  return reflection.isInstance(item, DataModel);
+}
+__name(isDataModel, "isDataModel");
+var DataModelAttribute = "DataModelAttribute";
+function isDataModelAttribute(item) {
+  return reflection.isInstance(item, DataModelAttribute);
+}
+__name(isDataModelAttribute, "isDataModelAttribute");
+var DataModelField = "DataModelField";
+function isDataModelField(item) {
+  return reflection.isInstance(item, DataModelField);
+}
+__name(isDataModelField, "isDataModelField");
+var DataModelFieldAttribute = "DataModelFieldAttribute";
+function isDataModelFieldAttribute(item) {
+  return reflection.isInstance(item, DataModelFieldAttribute);
+}
+__name(isDataModelFieldAttribute, "isDataModelFieldAttribute");
+var DataModelFieldType = "DataModelFieldType";
+function isDataModelFieldType(item) {
+  return reflection.isInstance(item, DataModelFieldType);
+}
+__name(isDataModelFieldType, "isDataModelFieldType");
+var DataSource = "DataSource";
+function isDataSource(item) {
+  return reflection.isInstance(item, DataSource);
+}
+__name(isDataSource, "isDataSource");
+var Enum = "Enum";
+function isEnum(item) {
+  return reflection.isInstance(item, Enum);
+}
+__name(isEnum, "isEnum");
+var EnumField = "EnumField";
+function isEnumField(item) {
+  return reflection.isInstance(item, EnumField);
+}
+__name(isEnumField, "isEnumField");
+var FieldInitializer = "FieldInitializer";
+function isFieldInitializer(item) {
+  return reflection.isInstance(item, FieldInitializer);
+}
+__name(isFieldInitializer, "isFieldInitializer");
+var FunctionDecl = "FunctionDecl";
+function isFunctionDecl(item) {
+  return reflection.isInstance(item, FunctionDecl);
+}
+__name(isFunctionDecl, "isFunctionDecl");
+var FunctionParam = "FunctionParam";
+function isFunctionParam(item) {
+  return reflection.isInstance(item, FunctionParam);
+}
+__name(isFunctionParam, "isFunctionParam");
+var FunctionParamType = "FunctionParamType";
+function isFunctionParamType(item) {
+  return reflection.isInstance(item, FunctionParamType);
+}
+__name(isFunctionParamType, "isFunctionParamType");
+var GeneratorDecl = "GeneratorDecl";
+function isGeneratorDecl(item) {
+  return reflection.isInstance(item, GeneratorDecl);
+}
+__name(isGeneratorDecl, "isGeneratorDecl");
+var InternalAttribute = "InternalAttribute";
+function isInternalAttribute(item) {
+  return reflection.isInstance(item, InternalAttribute);
+}
+__name(isInternalAttribute, "isInternalAttribute");
+var InvocationExpr = "InvocationExpr";
+function isInvocationExpr(item) {
+  return reflection.isInstance(item, InvocationExpr);
+}
+__name(isInvocationExpr, "isInvocationExpr");
+var MemberAccessExpr = "MemberAccessExpr";
+function isMemberAccessExpr(item) {
+  return reflection.isInstance(item, MemberAccessExpr);
+}
+__name(isMemberAccessExpr, "isMemberAccessExpr");
+var Model = "Model";
+function isModel(item) {
+  return reflection.isInstance(item, Model);
+}
+__name(isModel, "isModel");
+var ModelImport = "ModelImport";
+function isModelImport(item) {
+  return reflection.isInstance(item, ModelImport);
+}
+__name(isModelImport, "isModelImport");
+var NullExpr = "NullExpr";
+function isNullExpr(item) {
+  return reflection.isInstance(item, NullExpr);
+}
+__name(isNullExpr, "isNullExpr");
+var NumberLiteral = "NumberLiteral";
+function isNumberLiteral(item) {
+  return reflection.isInstance(item, NumberLiteral);
+}
+__name(isNumberLiteral, "isNumberLiteral");
+var ObjectExpr = "ObjectExpr";
+function isObjectExpr(item) {
+  return reflection.isInstance(item, ObjectExpr);
+}
+__name(isObjectExpr, "isObjectExpr");
+var Plugin = "Plugin";
+function isPlugin(item) {
+  return reflection.isInstance(item, Plugin);
+}
+__name(isPlugin, "isPlugin");
+var PluginField = "PluginField";
+function isPluginField(item) {
+  return reflection.isInstance(item, PluginField);
+}
+__name(isPluginField, "isPluginField");
+var Procedure = "Procedure";
+function isProcedure(item) {
+  return reflection.isInstance(item, Procedure);
+}
+__name(isProcedure, "isProcedure");
+var ProcedureParam = "ProcedureParam";
+function isProcedureParam(item) {
+  return reflection.isInstance(item, ProcedureParam);
+}
+__name(isProcedureParam, "isProcedureParam");
+var ReferenceArg = "ReferenceArg";
+function isReferenceArg(item) {
+  return reflection.isInstance(item, ReferenceArg);
+}
+__name(isReferenceArg, "isReferenceArg");
+var ReferenceExpr = "ReferenceExpr";
+function isReferenceExpr(item) {
+  return reflection.isInstance(item, ReferenceExpr);
+}
+__name(isReferenceExpr, "isReferenceExpr");
+var StringLiteral = "StringLiteral";
+function isStringLiteral(item) {
+  return reflection.isInstance(item, StringLiteral);
+}
+__name(isStringLiteral, "isStringLiteral");
+var ThisExpr = "ThisExpr";
+function isThisExpr(item) {
+  return reflection.isInstance(item, ThisExpr);
+}
+__name(isThisExpr, "isThisExpr");
+var TypeDef = "TypeDef";
+function isTypeDef(item) {
+  return reflection.isInstance(item, TypeDef);
+}
+__name(isTypeDef, "isTypeDef");
+var TypeDefField = "TypeDefField";
+function isTypeDefField(item) {
+  return reflection.isInstance(item, TypeDefField);
+}
+__name(isTypeDefField, "isTypeDefField");
+var TypeDefFieldType = "TypeDefFieldType";
+function isTypeDefFieldType(item) {
+  return reflection.isInstance(item, TypeDefFieldType);
+}
+__name(isTypeDefFieldType, "isTypeDefFieldType");
+var UnaryExpr = "UnaryExpr";
+function isUnaryExpr(item) {
+  return reflection.isInstance(item, UnaryExpr);
+}
+__name(isUnaryExpr, "isUnaryExpr");
+var UnsupportedFieldType = "UnsupportedFieldType";
+function isUnsupportedFieldType(item) {
+  return reflection.isInstance(item, UnsupportedFieldType);
+}
+__name(isUnsupportedFieldType, "isUnsupportedFieldType");
+var ZModelAstReflection = class extends AbstractAstReflection {
+  static {
+    __name(this, "ZModelAstReflection");
+  }
+  getAllTypes() {
+    return [
+      AbstractDeclaration,
+      Argument,
+      ArrayExpr,
+      Attribute,
+      AttributeArg,
+      AttributeParam,
+      AttributeParamType,
+      BinaryExpr,
+      BooleanLiteral,
+      ConfigArrayExpr,
+      ConfigExpr,
+      ConfigField,
+      ConfigInvocationArg,
+      ConfigInvocationExpr,
+      DataModel,
+      DataModelAttribute,
+      DataModelField,
+      DataModelFieldAttribute,
+      DataModelFieldType,
+      DataSource,
+      Enum,
+      EnumField,
+      Expression,
+      FieldInitializer,
+      FunctionDecl,
+      FunctionParam,
+      FunctionParamType,
+      GeneratorDecl,
+      InternalAttribute,
+      InvocationExpr,
+      LiteralExpr,
+      MemberAccessExpr,
+      MemberAccessTarget,
+      Model,
+      ModelImport,
+      NullExpr,
+      NumberLiteral,
+      ObjectExpr,
+      Plugin,
+      PluginField,
+      Procedure,
+      ProcedureParam,
+      ReferenceArg,
+      ReferenceExpr,
+      ReferenceTarget,
+      StringLiteral,
+      ThisExpr,
+      TypeDeclaration,
+      TypeDef,
+      TypeDefField,
+      TypeDefFieldType,
+      TypeDefFieldTypes,
+      UnaryExpr,
+      UnsupportedFieldType
+    ];
+  }
+  computeIsSubtype(subtype, supertype) {
+    switch (subtype) {
+      case ArrayExpr:
+      case BinaryExpr:
+      case MemberAccessExpr:
+      case NullExpr:
+      case ObjectExpr:
+      case ReferenceExpr:
+      case ThisExpr:
+      case UnaryExpr: {
+        return this.isSubtype(Expression, supertype);
+      }
+      case Attribute:
+      case DataSource:
+      case FunctionDecl:
+      case GeneratorDecl:
+      case Plugin:
+      case Procedure: {
+        return this.isSubtype(AbstractDeclaration, supertype);
+      }
+      case BooleanLiteral:
+      case NumberLiteral:
+      case StringLiteral: {
+        return this.isSubtype(LiteralExpr, supertype);
+      }
+      case ConfigArrayExpr: {
+        return this.isSubtype(ConfigExpr, supertype);
+      }
+      case DataModel: {
+        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
+      }
+      case DataModelField:
+      case TypeDefField: {
+        return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype);
+      }
+      case Enum:
+      case TypeDef: {
+        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype) || this.isSubtype(TypeDefFieldTypes, supertype);
+      }
+      case EnumField:
+      case FunctionParam: {
+        return this.isSubtype(ReferenceTarget, supertype);
+      }
+      case InvocationExpr:
+      case LiteralExpr: {
+        return this.isSubtype(ConfigExpr, supertype) || this.isSubtype(Expression, supertype);
+      }
+      default: {
+        return false;
+      }
+    }
+  }
+  getReferenceType(refInfo) {
+    const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
+    switch (referenceId) {
+      case "AttributeParamType:reference":
+      case "DataModelFieldType:reference":
+      case "FunctionParamType:reference": {
+        return TypeDeclaration;
+      }
+      case "DataModel:superTypes": {
+        return DataModel;
+      }
+      case "DataModelAttribute:decl":
+      case "DataModelFieldAttribute:decl":
+      case "InternalAttribute:decl": {
+        return Attribute;
+      }
+      case "InvocationExpr:function": {
+        return FunctionDecl;
+      }
+      case "MemberAccessExpr:member": {
+        return MemberAccessTarget;
+      }
+      case "ReferenceExpr:target": {
+        return ReferenceTarget;
+      }
+      case "TypeDefFieldType:reference": {
+        return TypeDefFieldTypes;
+      }
+      default: {
+        throw new Error(`${referenceId} is not a valid reference id.`);
+      }
+    }
+  }
+  getTypeMetaData(type) {
+    switch (type) {
+      case Argument: {
+        return {
+          name: Argument,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ArrayExpr: {
+        return {
+          name: ArrayExpr,
+          properties: [
+            {
+              name: "items",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case Attribute: {
+        return {
+          name: Attribute,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "params",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case AttributeArg: {
+        return {
+          name: AttributeArg,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case AttributeParam: {
+        return {
+          name: AttributeParam,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "default",
+              defaultValue: false
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case AttributeParamType: {
+        return {
+          name: AttributeParamType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case BinaryExpr: {
+        return {
+          name: BinaryExpr,
+          properties: [
+            {
+              name: "left"
+            },
+            {
+              name: "operator"
+            },
+            {
+              name: "right"
+            }
+          ]
+        };
+      }
+      case BooleanLiteral: {
+        return {
+          name: BooleanLiteral,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ConfigArrayExpr: {
+        return {
+          name: ConfigArrayExpr,
+          properties: [
+            {
+              name: "items",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case ConfigField: {
+        return {
+          name: ConfigField,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ConfigInvocationArg: {
+        return {
+          name: ConfigInvocationArg,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ConfigInvocationExpr: {
+        return {
+          name: ConfigInvocationExpr,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case DataModel: {
+        return {
+          name: DataModel,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "isAbstract",
+              defaultValue: false
+            },
+            {
+              name: "isView",
+              defaultValue: false
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "superTypes",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case DataModelAttribute: {
+        return {
+          name: DataModelAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "decl"
+            }
+          ]
+        };
+      }
+      case DataModelField: {
+        return {
+          name: DataModelField,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case DataModelFieldAttribute: {
+        return {
+          name: DataModelFieldAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "decl"
+            }
+          ]
+        };
+      }
+      case DataModelFieldType: {
+        return {
+          name: DataModelFieldType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            },
+            {
+              name: "unsupported"
+            }
+          ]
+        };
+      }
+      case DataSource: {
+        return {
+          name: DataSource,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case Enum: {
+        return {
+          name: Enum,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case EnumField: {
+        return {
+          name: EnumField,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case FieldInitializer: {
+        return {
+          name: FieldInitializer,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case FunctionDecl: {
+        return {
+          name: FunctionDecl,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "expression"
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "params",
+              defaultValue: []
+            },
+            {
+              name: "returnType"
+            }
+          ]
+        };
+      }
+      case FunctionParam: {
+        return {
+          name: FunctionParam,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case FunctionParamType: {
+        return {
+          name: FunctionParamType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case GeneratorDecl: {
+        return {
+          name: GeneratorDecl,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case InternalAttribute: {
+        return {
+          name: InternalAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "decl"
+            }
+          ]
+        };
+      }
+      case InvocationExpr: {
+        return {
+          name: InvocationExpr,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "function"
+            }
+          ]
+        };
+      }
+      case MemberAccessExpr: {
+        return {
+          name: MemberAccessExpr,
+          properties: [
+            {
+              name: "member"
+            },
+            {
+              name: "operand"
+            }
+          ]
+        };
+      }
+      case Model: {
+        return {
+          name: Model,
+          properties: [
+            {
+              name: "declarations",
+              defaultValue: []
+            },
+            {
+              name: "imports",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case ModelImport: {
+        return {
+          name: ModelImport,
+          properties: [
+            {
+              name: "path"
+            }
+          ]
+        };
+      }
+      case NullExpr: {
+        return {
+          name: NullExpr,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case NumberLiteral: {
+        return {
+          name: NumberLiteral,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ObjectExpr: {
+        return {
+          name: ObjectExpr,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            }
+          ]
+        };
+      }
+      case Plugin: {
+        return {
+          name: Plugin,
+          properties: [
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case PluginField: {
+        return {
+          name: PluginField,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case Procedure: {
+        return {
+          name: Procedure,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "mutation",
+              defaultValue: false
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "params",
+              defaultValue: []
+            },
+            {
+              name: "returnType"
+            }
+          ]
+        };
+      }
+      case ProcedureParam: {
+        return {
+          name: ProcedureParam,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case ReferenceArg: {
+        return {
+          name: ReferenceArg,
+          properties: [
+            {
+              name: "name"
+            },
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ReferenceExpr: {
+        return {
+          name: ReferenceExpr,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
+            },
+            {
+              name: "target"
+            }
+          ]
+        };
+      }
+      case StringLiteral: {
+        return {
+          name: StringLiteral,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case ThisExpr: {
+        return {
+          name: ThisExpr,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      case TypeDef: {
+        return {
+          name: TypeDef,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            }
+          ]
+        };
+      }
+      case TypeDefField: {
+        return {
+          name: TypeDefField,
+          properties: [
+            {
+              name: "attributes",
+              defaultValue: []
+            },
+            {
+              name: "comments",
+              defaultValue: []
+            },
+            {
+              name: "name"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case TypeDefFieldType: {
+        return {
+          name: TypeDefFieldType,
+          properties: [
+            {
+              name: "array",
+              defaultValue: false
+            },
+            {
+              name: "optional",
+              defaultValue: false
+            },
+            {
+              name: "reference"
+            },
+            {
+              name: "type"
+            }
+          ]
+        };
+      }
+      case UnaryExpr: {
+        return {
+          name: UnaryExpr,
+          properties: [
+            {
+              name: "operand"
+            },
+            {
+              name: "operator"
+            }
+          ]
+        };
+      }
+      case UnsupportedFieldType: {
+        return {
+          name: UnsupportedFieldType,
+          properties: [
+            {
+              name: "value"
+            }
+          ]
+        };
+      }
+      default: {
+        return {
+          name: type,
+          properties: []
+        };
+      }
+    }
+  }
+};
+var reflection = new ZModelAstReflection();
+
+// src/ast.ts
+var BinaryExprOperatorPriority = {
+  //LogicalExpr
+  "||": 1,
+  "&&": 1,
+  //EqualityExpr
+  "==": 2,
+  "!=": 2,
+  //ComparisonExpr
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  in: 4,
+  //CollectionPredicateExpr
+  "^": 5,
+  "?": 5,
+  "!": 5
+};
+export {
+  AbstractDeclaration,
+  Argument,
+  ArrayExpr,
+  Attribute,
+  AttributeArg,
+  AttributeParam,
+  AttributeParamType,
+  BinaryExpr,
+  BinaryExprOperatorPriority,
+  BooleanLiteral,
+  ConfigArrayExpr,
+  ConfigExpr,
+  ConfigField,
+  ConfigInvocationArg,
+  ConfigInvocationExpr,
+  DataModel,
+  DataModelAttribute,
+  DataModelField,
+  DataModelFieldAttribute,
+  DataModelFieldType,
+  DataSource,
+  Enum,
+  EnumField,
+  Expression,
+  FieldInitializer,
+  FunctionDecl,
+  FunctionParam,
+  FunctionParamType,
+  GeneratorDecl,
+  InternalAttribute,
+  InvocationExpr,
+  LiteralExpr,
+  MemberAccessExpr,
+  MemberAccessTarget,
+  Model,
+  ModelImport,
+  NullExpr,
+  NumberLiteral,
+  ObjectExpr,
+  Plugin,
+  PluginField,
+  Procedure,
+  ProcedureParam,
+  ReferenceArg,
+  ReferenceExpr,
+  ReferenceTarget,
+  StringLiteral,
+  ThisExpr,
+  TypeDeclaration,
+  TypeDef,
+  TypeDefField,
+  TypeDefFieldType,
+  TypeDefFieldTypes,
+  UnaryExpr,
+  UnsupportedFieldType,
+  ZModelAstReflection,
+  ZModelTerminals,
+  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
+};
+//# sourceMappingURL=ast.js.map