@zenstackhq/language 3.5.6 → 3.6.0

package/dist/factory.cjs

@@ -1,2087 +1,811 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/factory/index.ts
-var factory_exports = {};
-__export(factory_exports, {
-  ArgumentFactory: () => ArgumentFactory,
-  ArrayExprFactory: () => ArrayExprFactory,
-  AstFactory: () => AstFactory,
-  AttributeArgFactory: () => AttributeArgFactory,
-  AttributeFactory: () => AttributeFactory,
-  AttributeParamFactory: () => AttributeParamFactory,
-  AttributeParamTypeFactory: () => AttributeParamTypeFactory,
-  BinaryExprFactory: () => BinaryExprFactory,
-  BooleanLiteralFactory: () => BooleanLiteralFactory,
-  DataFieldAttributeFactory: () => DataFieldAttributeFactory,
-  DataFieldFactory: () => DataFieldFactory,
-  DataFieldTypeFactory: () => DataFieldTypeFactory,
-  DataModelAttributeFactory: () => DataModelAttributeFactory,
-  DataModelFactory: () => DataModelFactory,
-  DeclarationBuilder: () => DeclarationBuilder,
-  EnumFactory: () => EnumFactory,
-  EnumFieldFactory: () => EnumFieldFactory,
-  ExpressionBuilder: () => ExpressionBuilder,
-  FieldInitializerFactory: () => FieldInitializerFactory,
-  InternalAttributeFactory: () => InternalAttributeFactory,
-  InvocationExprFactory: () => InvocationExprFactory,
-  MemberAccessExprFactory: () => MemberAccessExprFactory,
-  ModelFactory: () => ModelFactory,
-  ModelImportFactory: () => ModelImportFactory,
-  NullExprFactory: () => NullExprFactory,
-  NumberLiteralFactory: () => NumberLiteralFactory,
-  ObjectExprFactory: () => ObjectExprFactory,
-  ReferenceArgFactory: () => ReferenceArgFactory,
-  ReferenceExprFactory: () => ReferenceExprFactory,
-  StringLiteralFactory: () => StringLiteralFactory,
-  ThisExprFactory: () => ThisExprFactory,
-  UnaryExprFactory: () => UnaryExprFactory,
-  UnsupportedFieldTypeFactory: () => UnsupportedFieldTypeFactory
-});
-module.exports = __toCommonJS(factory_exports);
-
-// src/factory/ast-factory.ts
-var AstFactory = class _AstFactory {
-  static {
-    __name(this, "AstFactory");
-  }
-  node = {};
-  constructor({ type, node }) {
-    this.node.$type = type;
-    if (node) {
-      this.update(node);
-    }
-  }
-  setContainer(container) {
-    this.node.$container = container;
-    return this;
-  }
-  get(params) {
-    if (params) this.update(params);
-    return this.node;
-  }
-  update(nodeArg) {
-    const keys = Object.keys(nodeArg);
-    keys.forEach((key) => {
-      const child = nodeArg[key];
-      if (child instanceof _AstFactory) {
-        this.node[key] = child.get({
-          $container: this.node
-        });
-      } else if (Array.isArray(child)) {
-        this.node[key] = child.map((item) => item instanceof _AstFactory ? item.get({
-          $container: this.node
-        }) : item);
-      } else {
-        this.node[key] = child;
-      }
-    });
-    return this.node;
-  }
-};
-
-// src/generated/ast.ts
-var langium = __toESM(require("langium"), 1);
-var AbstractDeclaration = "AbstractDeclaration";
-var ConfigExpr = "ConfigExpr";
-var Expression = "Expression";
-var LiteralExpr = "LiteralExpr";
-var MemberAccessTarget = "MemberAccessTarget";
-var ReferenceTarget = "ReferenceTarget";
-var TypeDeclaration = "TypeDeclaration";
-var Argument = "Argument";
-var ArrayExpr = "ArrayExpr";
-var Attribute = "Attribute";
-var AttributeArg = "AttributeArg";
-var AttributeParam = "AttributeParam";
-var AttributeParamType = "AttributeParamType";
-var BinaryExpr = "BinaryExpr";
-var BooleanLiteral = "BooleanLiteral";
-var CollectionPredicateBinding = "CollectionPredicateBinding";
-var ConfigArrayExpr = "ConfigArrayExpr";
-var ConfigField = "ConfigField";
-var ConfigInvocationArg = "ConfigInvocationArg";
-var ConfigInvocationExpr = "ConfigInvocationExpr";
-var DataField = "DataField";
-var DataFieldAttribute = "DataFieldAttribute";
-var DataFieldType = "DataFieldType";
-var DataModel = "DataModel";
-var DataModelAttribute = "DataModelAttribute";
-var DataSource = "DataSource";
-var Enum = "Enum";
-var EnumField = "EnumField";
-var FieldInitializer = "FieldInitializer";
-var FunctionDecl = "FunctionDecl";
-var FunctionParam = "FunctionParam";
-var FunctionParamType = "FunctionParamType";
-var GeneratorDecl = "GeneratorDecl";
-var InternalAttribute = "InternalAttribute";
-var InvocationExpr = "InvocationExpr";
-var MemberAccessExpr = "MemberAccessExpr";
-var Model = "Model";
-var ModelImport = "ModelImport";
-var NullExpr = "NullExpr";
-var NumberLiteral = "NumberLiteral";
-var ObjectExpr = "ObjectExpr";
-var Plugin = "Plugin";
-var PluginField = "PluginField";
-var Procedure = "Procedure";
-var ProcedureParam = "ProcedureParam";
-var ReferenceArg = "ReferenceArg";
-var ReferenceExpr = "ReferenceExpr";
-var StringLiteral = "StringLiteral";
-var ThisExpr = "ThisExpr";
-var TypeDef = "TypeDef";
-var UnaryExpr = "UnaryExpr";
-var UnsupportedFieldType = "UnsupportedFieldType";
-var ZModelAstReflection = class extends langium.AbstractAstReflection {
-  static {
-    __name(this, "ZModelAstReflection");
-  }
-  getAllTypes() {
-    return [
-      AbstractDeclaration,
-      Argument,
-      ArrayExpr,
-      Attribute,
-      AttributeArg,
-      AttributeParam,
-      AttributeParamType,
-      BinaryExpr,
-      BooleanLiteral,
-      CollectionPredicateBinding,
-      ConfigArrayExpr,
-      ConfigExpr,
-      ConfigField,
-      ConfigInvocationArg,
-      ConfigInvocationExpr,
-      DataField,
-      DataFieldAttribute,
-      DataFieldType,
-      DataModel,
-      DataModelAttribute,
-      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,
-      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 CollectionPredicateBinding:
-      case EnumField:
-      case FunctionParam: {
-        return this.isSubtype(ReferenceTarget, supertype);
-      }
-      case ConfigArrayExpr: {
-        return this.isSubtype(ConfigExpr, supertype);
-      }
-      case DataField: {
-        return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype);
-      }
-      case DataModel:
-      case Enum:
-      case TypeDef: {
-        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, 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 "DataFieldType:reference":
-      case "FunctionParamType:reference": {
-        return TypeDeclaration;
-      }
-      case "DataFieldAttribute:decl":
-      case "DataModelAttribute:decl":
-      case "InternalAttribute:decl": {
-        return Attribute;
-      }
-      case "DataModel:baseModel": {
-        return DataModel;
-      }
-      case "DataModel:mixins":
-      case "TypeDef:mixins": {
-        return TypeDef;
-      }
-      case "InvocationExpr:function": {
-        return FunctionDecl;
-      }
-      case "MemberAccessExpr:member": {
-        return MemberAccessTarget;
-      }
-      case "ReferenceExpr:target": {
-        return ReferenceTarget;
-      }
-      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: "binding"
-            },
-            {
-              name: "left"
-            },
-            {
-              name: "operator"
-            },
-            {
-              name: "right"
-            }
-          ]
-        };
-      }
-      case BooleanLiteral: {
-        return {
-          name: BooleanLiteral,
-          properties: [
-            {
-              name: "value"
-            }
-          ]
-        };
-      }
-      case CollectionPredicateBinding: {
-        return {
-          name: CollectionPredicateBinding,
-          properties: [
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      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 DataField: {
-        return {
-          name: DataField,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case DataFieldAttribute: {
-        return {
-          name: DataFieldAttribute,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      case DataFieldType: {
-        return {
-          name: DataFieldType,
-          properties: [
-            {
-              name: "array",
-              defaultValue: false
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "reference"
-            },
-            {
-              name: "type"
-            },
-            {
-              name: "unsupported"
-            }
-          ]
-        };
-      }
-      case DataModel: {
-        return {
-          name: DataModel,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "baseModel"
-            },
-            {
-              name: "comments",
-              defaultValue: []
-            },
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "isView",
-              defaultValue: false
-            },
-            {
-              name: "mixins",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case DataModelAttribute: {
-        return {
-          name: DataModelAttribute,
-          properties: [
-            {
-              name: "args",
-              defaultValue: []
-            },
-            {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      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: "mixins",
-              defaultValue: []
-            },
-            {
-              name: "name"
-            }
-          ]
-        };
-      }
-      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/factory/primitives.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ast = require("./ast-Clidp86c.cjs");
+require("./ast.cjs");
+//#region src/factory/ast-factory.ts
+var AstFactory = class AstFactory {
+	node = {};
+	constructor({ type, node }) {
+		this.node.$type = type;
+		if (node) this.update(node);
+	}
+	setContainer(container) {
+		this.node.$container = container;
+		return this;
+	}
+	get(params) {
+		if (params) this.update(params);
+		return this.node;
+	}
+	update(nodeArg) {
+		Object.keys(nodeArg).forEach((key) => {
+			const child = nodeArg[key];
+			if (child instanceof AstFactory) this.node[key] = child.get({ $container: this.node });
+			else if (Array.isArray(child)) this.node[key] = child.map((item) => item instanceof AstFactory ? item.get({ $container: this.node }) : item);
+			else this.node[key] = child;
+		});
+		return this.node;
+	}
+};
+//#endregion
+//#region src/factory/primitives.ts
 var ThisExprFactory = class extends AstFactory {
-  static {
-    __name(this, "ThisExprFactory");
-  }
-  constructor() {
-    super({
-      type: ThisExpr,
-      node: {
-        value: "this"
-      }
-    });
-  }
+	constructor() {
+		super({
+			type: require_ast.ThisExpr,
+			node: { value: "this" }
+		});
+	}
 };
 var NullExprFactory = class extends AstFactory {
-  static {
-    __name(this, "NullExprFactory");
-  }
-  constructor() {
-    super({
-      type: NullExpr,
-      node: {
-        value: "null"
-      }
-    });
-  }
+	constructor() {
+		super({
+			type: require_ast.NullExpr,
+			node: { value: "null" }
+		});
+	}
 };
 var NumberLiteralFactory = class extends AstFactory {
-  static {
-    __name(this, "NumberLiteralFactory");
-  }
-  value;
-  constructor() {
-    super({
-      type: NumberLiteral
-    });
-  }
-  setValue(value) {
-    this.value = value;
-    this.update({
-      value: this.value.toString()
-    });
-    return this;
-  }
+	value;
+	constructor() {
+		super({ type: require_ast.NumberLiteral });
+	}
+	setValue(value) {
+		this.value = value;
+		this.update({ value: this.value.toString() });
+		return this;
+	}
 };
 var StringLiteralFactory = class extends AstFactory {
-  static {
-    __name(this, "StringLiteralFactory");
-  }
-  value;
-  constructor() {
-    super({
-      type: StringLiteral
-    });
-  }
-  setValue(value) {
-    this.value = value;
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
+	value;
+	constructor() {
+		super({ type: require_ast.StringLiteral });
+	}
+	setValue(value) {
+		this.value = value;
+		this.update({ value: this.value });
+		return this;
+	}
 };
 var BooleanLiteralFactory = class extends AstFactory {
-  static {
-    __name(this, "BooleanLiteralFactory");
-  }
-  value;
-  constructor() {
-    super({
-      type: BooleanLiteral
-    });
-  }
-  setValue(value) {
-    this.value = value;
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
-};
-
-// src/factory/expression.ts
-var ExpressionBuilder = /* @__PURE__ */ __name(() => ({
-  get ArrayExpr() {
-    return new ArrayExprFactory();
-  },
-  get BinaryExpr() {
-    return new BinaryExprFactory();
-  },
-  get BooleanLiteral() {
-    return new BooleanLiteralFactory();
-  },
-  get InvocationExpr() {
-    return new InvocationExprFactory();
-  },
-  get MemberAccessExpr() {
-    return new MemberAccessExprFactory();
-  },
-  get NullExpr() {
-    return new NullExprFactory();
-  },
-  get NumberLiteral() {
-    return new NumberLiteralFactory();
-  },
-  get ObjectExpr() {
-    return new ObjectExprFactory();
-  },
-  get ReferenceExpr() {
-    return new ReferenceExprFactory();
-  },
-  get StringLiteral() {
-    return new StringLiteralFactory();
-  },
-  get ThisExpr() {
-    return new ThisExprFactory();
-  },
-  get UnaryExpr() {
-    return new UnaryExprFactory();
-  }
-}), "ExpressionBuilder");
+	value;
+	constructor() {
+		super({ type: require_ast.BooleanLiteral });
+	}
+	setValue(value) {
+		this.value = value;
+		this.update({ value: this.value });
+		return this;
+	}
+};
+//#endregion
+//#region src/factory/expression.ts
+const ExpressionBuilder = () => ({
+	get ArrayExpr() {
+		return new ArrayExprFactory();
+	},
+	get BinaryExpr() {
+		return new BinaryExprFactory();
+	},
+	get BooleanLiteral() {
+		return new BooleanLiteralFactory();
+	},
+	get InvocationExpr() {
+		return new InvocationExprFactory();
+	},
+	get MemberAccessExpr() {
+		return new MemberAccessExprFactory();
+	},
+	get NullExpr() {
+		return new NullExprFactory();
+	},
+	get NumberLiteral() {
+		return new NumberLiteralFactory();
+	},
+	get ObjectExpr() {
+		return new ObjectExprFactory();
+	},
+	get ReferenceExpr() {
+		return new ReferenceExprFactory();
+	},
+	get StringLiteral() {
+		return new StringLiteralFactory();
+	},
+	get ThisExpr() {
+		return new ThisExprFactory();
+	},
+	get UnaryExpr() {
+		return new UnaryExprFactory();
+	}
+});
 var UnaryExprFactory = class extends AstFactory {
-  static {
-    __name(this, "UnaryExprFactory");
-  }
-  operand;
-  constructor() {
-    super({
-      type: UnaryExpr,
-      node: {
-        operator: "!"
-      }
-    });
-  }
-  setOperand(builder) {
-    this.operand = builder(ExpressionBuilder());
-    this.update({
-      operand: this.operand
-    });
-    return this;
-  }
+	operand;
+	constructor() {
+		super({
+			type: require_ast.UnaryExpr,
+			node: { operator: "!" }
+		});
+	}
+	setOperand(builder) {
+		this.operand = builder(ExpressionBuilder());
+		this.update({ operand: this.operand });
+		return this;
+	}
 };
 var ReferenceExprFactory = class extends AstFactory {
-  static {
-    __name(this, "ReferenceExprFactory");
-  }
-  target;
-  args = [];
-  constructor() {
-    super({
-      type: ReferenceExpr,
-      node: {
-        args: []
-      }
-    });
-  }
-  setTarget(target) {
-    this.target = {
-      $refText: target.name,
-      ref: target
-    };
-    this.update({
-      target: this.target
-    });
-    return this;
-  }
-  addArg(builder, name) {
-    const arg = new ReferenceArgFactory().setValue(builder);
-    if (name) {
-      arg.setName(name);
-    }
-    this.args.push(arg);
-    this.update({
-      args: this.args
-    });
-    return this;
-  }
+	target;
+	args = [];
+	constructor() {
+		super({
+			type: require_ast.ReferenceExpr,
+			node: { args: [] }
+		});
+	}
+	setTarget(target) {
+		this.target = {
+			$refText: target.name,
+			ref: target
+		};
+		this.update({ target: this.target });
+		return this;
+	}
+	addArg(builder, name) {
+		const arg = new ReferenceArgFactory().setValue(builder);
+		if (name) arg.setName(name);
+		this.args.push(arg);
+		this.update({ args: this.args });
+		return this;
+	}
 };
 var ReferenceArgFactory = class extends AstFactory {
-  static {
-    __name(this, "ReferenceArgFactory");
-  }
-  name;
-  value;
-  constructor() {
-    super({
-      type: ReferenceArg
-    });
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  setValue(builder) {
-    this.value = builder(ExpressionBuilder());
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
+	name;
+	value;
+	constructor() {
+		super({ type: require_ast.ReferenceArg });
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
 };
 var MemberAccessExprFactory = class extends AstFactory {
-  static {
-    __name(this, "MemberAccessExprFactory");
-  }
-  member;
-  operand;
-  constructor() {
-    super({
-      type: MemberAccessExpr
-    });
-  }
-  setMember(target) {
-    this.member = target;
-    this.update({
-      member: this.member
-    });
-    return this;
-  }
-  setOperand(builder) {
-    this.operand = builder(ExpressionBuilder());
-    this.update({
-      operand: this.operand
-    });
-    return this;
-  }
+	member;
+	operand;
+	constructor() {
+		super({ type: require_ast.MemberAccessExpr });
+	}
+	setMember(target) {
+		this.member = target;
+		this.update({ member: this.member });
+		return this;
+	}
+	setOperand(builder) {
+		this.operand = builder(ExpressionBuilder());
+		this.update({ operand: this.operand });
+		return this;
+	}
 };
 var ObjectExprFactory = class extends AstFactory {
-  static {
-    __name(this, "ObjectExprFactory");
-  }
-  fields = [];
-  constructor() {
-    super({
-      type: ObjectExpr,
-      node: {
-        fields: []
-      }
-    });
-  }
-  addField(builder) {
-    this.fields.push(builder(new FieldInitializerFactory()));
-    this.update({
-      fields: this.fields
-    });
-    return this;
-  }
+	fields = [];
+	constructor() {
+		super({
+			type: require_ast.ObjectExpr,
+			node: { fields: [] }
+		});
+	}
+	addField(builder) {
+		this.fields.push(builder(new FieldInitializerFactory()));
+		this.update({ fields: this.fields });
+		return this;
+	}
 };
 var FieldInitializerFactory = class extends AstFactory {
-  static {
-    __name(this, "FieldInitializerFactory");
-  }
-  name;
-  value;
-  constructor() {
-    super({
-      type: FieldInitializer
-    });
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  setValue(builder) {
-    this.value = builder(ExpressionBuilder());
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
+	name;
+	value;
+	constructor() {
+		super({ type: require_ast.FieldInitializer });
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
 };
 var InvocationExprFactory = class extends AstFactory {
-  static {
-    __name(this, "InvocationExprFactory");
-  }
-  args = [];
-  function;
-  constructor() {
-    super({
-      type: InvocationExpr,
-      node: {
-        args: []
-      }
-    });
-  }
-  addArg(builder) {
-    this.args.push(builder(new ArgumentFactory()));
-    this.update({
-      args: this.args
-    });
-    return this;
-  }
-  setFunction(value) {
-    this.function = {
-      $refText: value.name,
-      ref: value
-    };
-    this.update({
-      function: this.function
-    });
-    return this;
-  }
+	args = [];
+	function;
+	constructor() {
+		super({
+			type: require_ast.InvocationExpr,
+			node: { args: [] }
+		});
+	}
+	addArg(builder) {
+		this.args.push(builder(new ArgumentFactory()));
+		this.update({ args: this.args });
+		return this;
+	}
+	setFunction(value) {
+		this.function = {
+			$refText: value.name,
+			ref: value
+		};
+		this.update({ function: this.function });
+		return this;
+	}
 };
 var ArgumentFactory = class extends AstFactory {
-  static {
-    __name(this, "ArgumentFactory");
-  }
-  value;
-  constructor() {
-    super({
-      type: Argument
-    });
-  }
-  setValue(builder) {
-    this.value = builder(ExpressionBuilder());
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
+	value;
+	constructor() {
+		super({ type: require_ast.Argument });
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
 };
 var ArrayExprFactory = class extends AstFactory {
-  static {
-    __name(this, "ArrayExprFactory");
-  }
-  items = [];
-  constructor() {
-    super({
-      type: ArrayExpr,
-      node: {
-        items: []
-      }
-    });
-  }
-  addItem(builder) {
-    this.items.push(builder(ExpressionBuilder()));
-    this.update({
-      items: this.items
-    });
-    return this;
-  }
+	items = [];
+	constructor() {
+		super({
+			type: require_ast.ArrayExpr,
+			node: { items: [] }
+		});
+	}
+	addItem(builder) {
+		this.items.push(builder(ExpressionBuilder()));
+		this.update({ items: this.items });
+		return this;
+	}
 };
 var BinaryExprFactory = class extends AstFactory {
-  static {
-    __name(this, "BinaryExprFactory");
-  }
-  operator;
-  right;
-  left;
-  // TODO: add support for CollectionPredicateBinding
-  constructor() {
-    super({
-      type: BinaryExpr
-    });
-  }
-  setOperator(operator) {
-    this.operator = operator;
-    this.update({
-      operator: this.operator
-    });
-    return this;
-  }
-  setRight(builder) {
-    this.right = builder(ExpressionBuilder());
-    this.update({
-      right: this.right
-    });
-    return this;
-  }
-  setLeft(builder) {
-    this.left = builder(ExpressionBuilder());
-    this.update({
-      left: this.left
-    });
-    return this;
-  }
-};
-
-// src/factory/attribute.ts
+	operator;
+	right;
+	left;
+	constructor() {
+		super({ type: require_ast.BinaryExpr });
+	}
+	setOperator(operator) {
+		this.operator = operator;
+		this.update({ operator: this.operator });
+		return this;
+	}
+	setRight(builder) {
+		this.right = builder(ExpressionBuilder());
+		this.update({ right: this.right });
+		return this;
+	}
+	setLeft(builder) {
+		this.left = builder(ExpressionBuilder());
+		this.update({ left: this.left });
+		return this;
+	}
+};
+//#endregion
+//#region src/factory/attribute.ts
 var DataFieldAttributeFactory = class extends AstFactory {
-  static {
-    __name(this, "DataFieldAttributeFactory");
-  }
-  args = [];
-  decl;
-  constructor() {
-    super({
-      type: DataFieldAttribute,
-      node: {
-        args: []
-      }
-    });
-  }
-  setDecl(decl) {
-    if (!decl) {
-      throw new Error("Attribute declaration is required");
-    }
-    this.decl = {
-      $refText: decl.name,
-      ref: decl
-    };
-    this.update({
-      decl: this.decl
-    });
-    return this;
-  }
-  addArg(builder, name) {
-    const factory = new AttributeArgFactory().setValue(builder);
-    if (name) {
-      factory.setName(name);
-    }
-    this.args.push(factory);
-    this.update({
-      args: this.args
-    });
-    return this;
-  }
+	args = [];
+	decl;
+	constructor() {
+		super({
+			type: require_ast.DataFieldAttribute,
+			node: { args: [] }
+		});
+	}
+	setDecl(decl) {
+		if (!decl) throw new Error("Attribute declaration is required");
+		this.decl = {
+			$refText: decl.name,
+			ref: decl
+		};
+		this.update({ decl: this.decl });
+		return this;
+	}
+	addArg(builder, name) {
+		const factory = new AttributeArgFactory().setValue(builder);
+		if (name) factory.setName(name);
+		this.args.push(factory);
+		this.update({ args: this.args });
+		return this;
+	}
 };
 var DataModelAttributeFactory = class extends AstFactory {
-  static {
-    __name(this, "DataModelAttributeFactory");
-  }
-  args = [];
-  decl;
-  constructor() {
-    super({
-      type: DataModelAttribute,
-      node: {
-        args: []
-      }
-    });
-  }
-  setDecl(decl) {
-    if (!decl) {
-      throw new Error("Attribute declaration is required");
-    }
-    this.decl = {
-      $refText: decl.name,
-      ref: decl
-    };
-    this.update({
-      decl: this.decl
-    });
-    return this;
-  }
-  addArg(builder, name) {
-    const factory = new AttributeArgFactory().setValue(builder);
-    if (name) {
-      factory.setName(name);
-    }
-    this.args.push(factory);
-    this.update({
-      args: this.args
-    });
-    return this;
-  }
+	args = [];
+	decl;
+	constructor() {
+		super({
+			type: require_ast.DataModelAttribute,
+			node: { args: [] }
+		});
+	}
+	setDecl(decl) {
+		if (!decl) throw new Error("Attribute declaration is required");
+		this.decl = {
+			$refText: decl.name,
+			ref: decl
+		};
+		this.update({ decl: this.decl });
+		return this;
+	}
+	addArg(builder, name) {
+		const factory = new AttributeArgFactory().setValue(builder);
+		if (name) factory.setName(name);
+		this.args.push(factory);
+		this.update({ args: this.args });
+		return this;
+	}
 };
 var AttributeArgFactory = class extends AstFactory {
-  static {
-    __name(this, "AttributeArgFactory");
-  }
-  name = "";
-  value;
-  constructor() {
-    super({
-      type: AttributeArg
-    });
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  setValue(builder) {
-    this.value = builder(ExpressionBuilder());
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
+	name = "";
+	value;
+	constructor() {
+		super({ type: require_ast.AttributeArg });
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
 };
 var InternalAttributeFactory = class extends AstFactory {
-  static {
-    __name(this, "InternalAttributeFactory");
-  }
-  decl;
-  args = [];
-  constructor() {
-    super({
-      type: InternalAttribute,
-      node: {
-        args: []
-      }
-    });
-  }
-  setDecl(decl) {
-    this.decl = {
-      $refText: decl.name,
-      ref: decl
-    };
-    this.update({
-      decl: this.decl
-    });
-    return this;
-  }
-  addArg(builder, name) {
-    const factory = new AttributeArgFactory().setValue(builder);
-    if (name) {
-      factory.setName(name);
-    }
-    this.args.push(factory);
-    this.update({
-      args: this.args
-    });
-    return this;
-  }
+	decl;
+	args = [];
+	constructor() {
+		super({
+			type: require_ast.InternalAttribute,
+			node: { args: [] }
+		});
+	}
+	setDecl(decl) {
+		this.decl = {
+			$refText: decl.name,
+			ref: decl
+		};
+		this.update({ decl: this.decl });
+		return this;
+	}
+	addArg(builder, name) {
+		const factory = new AttributeArgFactory().setValue(builder);
+		if (name) factory.setName(name);
+		this.args.push(factory);
+		this.update({ args: this.args });
+		return this;
+	}
 };
 var AttributeParamFactory = class extends AstFactory {
-  static {
-    __name(this, "AttributeParamFactory");
-  }
-  attributes = [];
-  comments = [];
-  default;
-  name;
-  type;
-  constructor() {
-    super({
-      type: AttributeParam,
-      node: {
-        comments: [],
-        attributes: []
-      }
-    });
-  }
-  addAttribute(builder) {
-    this.attributes.push(builder(new InternalAttributeFactory()));
-    this.update({
-      attributes: this.attributes
-    });
-    return this;
-  }
-  setComments(comments) {
-    this.comments = comments;
-    this.update({
-      comments: this.comments
-    });
-    return this;
-  }
-  setDefault(defaultValue) {
-    this.default = defaultValue;
-    this.update({
-      default: this.default
-    });
-    return this;
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  setType(builder) {
-    this.type = builder(new AttributeParamTypeFactory());
-    this.update({
-      type: this.type
-    });
-    return this;
-  }
+	attributes = [];
+	comments = [];
+	default;
+	name;
+	type;
+	constructor() {
+		super({
+			type: require_ast.AttributeParam,
+			node: {
+				comments: [],
+				attributes: []
+			}
+		});
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new InternalAttributeFactory()));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	setDefault(defaultValue) {
+		this.default = defaultValue;
+		this.update({ default: this.default });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setType(builder) {
+		this.type = builder(new AttributeParamTypeFactory());
+		this.update({ type: this.type });
+		return this;
+	}
 };
 var AttributeParamTypeFactory = class extends AstFactory {
-  static {
-    __name(this, "AttributeParamTypeFactory");
-  }
-  array;
-  optional;
-  reference;
-  type;
-  constructor() {
-    super({
-      type: AttributeParamType
-    });
-  }
-  setArray(array) {
-    this.array = array;
-    this.update({
-      array: this.array
-    });
-    return this;
-  }
-  setOptional(optional) {
-    this.optional = optional;
-    this.update({
-      optional: this.optional
-    });
-    return this;
-  }
-  setReference(reference) {
-    this.reference = {
-      $refText: reference.name,
-      ref: reference
-    };
-    this.update({
-      reference: this.reference
-    });
-    return this;
-  }
-  setType(type) {
-    this.type = type;
-    this.update({
-      type: this.type
-    });
-    return this;
-  }
+	array;
+	optional;
+	reference;
+	type;
+	constructor() {
+		super({ type: require_ast.AttributeParamType });
+	}
+	setArray(array) {
+		this.array = array;
+		this.update({ array: this.array });
+		return this;
+	}
+	setOptional(optional) {
+		this.optional = optional;
+		this.update({ optional: this.optional });
+		return this;
+	}
+	setReference(reference) {
+		this.reference = {
+			$refText: reference.name,
+			ref: reference
+		};
+		this.update({ reference: this.reference });
+		return this;
+	}
+	setType(type) {
+		this.type = type;
+		this.update({ type: this.type });
+		return this;
+	}
 };
 var AttributeFactory = class extends AstFactory {
-  static {
-    __name(this, "AttributeFactory");
-  }
-  name;
-  comments = [];
-  attributes = [];
-  params = [];
-  constructor() {
-    super({
-      type: Attribute,
-      node: {
-        comments: [],
-        attributes: [],
-        params: []
-      }
-    });
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  setComments(comments) {
-    this.comments = comments;
-    this.update({
-      comments: this.comments
-    });
-    return this;
-  }
-  addAttribute(builder) {
-    this.attributes.push(builder(new InternalAttributeFactory()));
-    this.update({
-      attributes: this.attributes
-    });
-    return this;
-  }
-  addParam(builder) {
-    this.params.push(builder(new AttributeParamFactory()));
-    this.update({
-      params: this.params
-    });
-    return this;
-  }
-};
-
-// src/factory/declaration.ts
-var DeclarationBuilder = /* @__PURE__ */ __name(() => ({
-  get Attribute() {
-    return new AttributeFactory();
-  },
-  get DataModel() {
-    return new DataModelFactory();
-  },
-  get DataSource() {
-    throw new Error("DataSource is not implemented");
-  },
-  get Enum() {
-    return new EnumFactory();
-  },
-  get FunctionDecl() {
-    throw new Error("FunctionDecl is not implemented");
-  },
-  get GeneratorDecl() {
-    throw new Error("GeneratorDecl is not implemented");
-  },
-  get Plugin() {
-    throw new Error("Plugin is not implemented");
-  },
-  get Procedure() {
-    throw new Error("Procedure is not implemented");
-  },
-  get TypeDef() {
-    throw new Error("TypeDef is not implemented");
-  }
-}), "DeclarationBuilder");
+	name;
+	comments = [];
+	attributes = [];
+	params = [];
+	constructor() {
+		super({
+			type: require_ast.Attribute,
+			node: {
+				comments: [],
+				attributes: [],
+				params: []
+			}
+		});
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new InternalAttributeFactory()));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	addParam(builder) {
+		this.params.push(builder(new AttributeParamFactory()));
+		this.update({ params: this.params });
+		return this;
+	}
+};
+//#endregion
+//#region src/factory/declaration.ts
+const DeclarationBuilder = () => ({
+	get Attribute() {
+		return new AttributeFactory();
+	},
+	get DataModel() {
+		return new DataModelFactory();
+	},
+	get DataSource() {
+		throw new Error("DataSource is not implemented");
+	},
+	get Enum() {
+		return new EnumFactory();
+	},
+	get FunctionDecl() {
+		throw new Error("FunctionDecl is not implemented");
+	},
+	get GeneratorDecl() {
+		throw new Error("GeneratorDecl is not implemented");
+	},
+	get Plugin() {
+		throw new Error("Plugin is not implemented");
+	},
+	get Procedure() {
+		throw new Error("Procedure is not implemented");
+	},
+	get TypeDef() {
+		throw new Error("TypeDef is not implemented");
+	}
+});
 var DataModelFactory = class extends AstFactory {
-  static {
-    __name(this, "DataModelFactory");
-  }
-  attributes = [];
-  baseModel;
-  comments = [];
-  fields = [];
-  isView;
-  mixins = [];
-  name;
-  constructor() {
-    super({
-      type: DataModel,
-      node: {
-        attributes: [],
-        comments: [],
-        fields: [],
-        mixins: []
-      }
-    });
-  }
-  addAttribute(builder) {
-    this.attributes.push(builder(new DataModelAttributeFactory()).setContainer(this.node));
-    this.update({
-      attributes: this.attributes
-    });
-    return this;
-  }
-  setBaseModel(model) {
-    this.baseModel = model;
-    this.update({
-      baseModel: this.baseModel
-    });
-    return this;
-  }
-  setComments(comments) {
-    this.comments = comments;
-    this.update({
-      comments: this.comments
-    });
-    return this;
-  }
-  addComment(comment) {
-    this.comments.push(comment);
-    this.update({
-      comments: this.comments
-    });
-    return this;
-  }
-  addField(builder) {
-    this.fields.push(builder(new DataFieldFactory()).setContainer(this.node));
-    this.update({
-      fields: this.fields
-    });
-    return this;
-  }
-  setIsView(isView) {
-    this.isView = isView;
-    this.update({
-      isView: this.isView
-    });
-    return this;
-  }
-  addMixin(mixin) {
-    this.mixins.push(mixin);
-    this.update({
-      mixins: this.mixins
-    });
-    return this;
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
+	attributes = [];
+	baseModel;
+	comments = [];
+	fields = [];
+	isView;
+	mixins = [];
+	name;
+	constructor() {
+		super({
+			type: require_ast.DataModel,
+			node: {
+				attributes: [],
+				comments: [],
+				fields: [],
+				mixins: []
+			}
+		});
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new DataModelAttributeFactory()).setContainer(this.node));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setBaseModel(model) {
+		this.baseModel = model;
+		this.update({ baseModel: this.baseModel });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	addComment(comment) {
+		this.comments.push(comment);
+		this.update({ comments: this.comments });
+		return this;
+	}
+	addField(builder) {
+		this.fields.push(builder(new DataFieldFactory()).setContainer(this.node));
+		this.update({ fields: this.fields });
+		return this;
+	}
+	setIsView(isView) {
+		this.isView = isView;
+		this.update({ isView: this.isView });
+		return this;
+	}
+	addMixin(mixin) {
+		this.mixins.push(mixin);
+		this.update({ mixins: this.mixins });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
 };
 var DataFieldFactory = class extends AstFactory {
-  static {
-    __name(this, "DataFieldFactory");
-  }
-  attributes = [];
-  comments = [];
-  name;
-  type;
-  constructor() {
-    super({
-      type: DataField,
-      node: {
-        attributes: [],
-        comments: []
-      }
-    });
-  }
-  addAttribute(builder) {
-    if (builder instanceof DataFieldAttributeFactory) {
-      builder.setContainer(this.node);
-      this.attributes.push(builder);
-    } else {
-      const attr = builder(new DataFieldAttributeFactory());
-      attr.setContainer(this.node);
-      this.attributes.push(attr);
-    }
-    this.update({
-      attributes: this.attributes
-    });
-    return this;
-  }
-  setComments(comments) {
-    this.comments = comments;
-    this.update({
-      comments: this.comments
-    });
-    return this;
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  setType(builder) {
-    this.type = builder(new DataFieldTypeFactory()).setContainer(this.node);
-    this.update({
-      type: this.type
-    });
-    return this;
-  }
+	attributes = [];
+	comments = [];
+	name;
+	type;
+	constructor() {
+		super({
+			type: require_ast.DataField,
+			node: {
+				attributes: [],
+				comments: []
+			}
+		});
+	}
+	addAttribute(builder) {
+		if (builder instanceof DataFieldAttributeFactory) {
+			builder.setContainer(this.node);
+			this.attributes.push(builder);
+		} else {
+			const attr = builder(new DataFieldAttributeFactory());
+			attr.setContainer(this.node);
+			this.attributes.push(attr);
+		}
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setComments(comments) {
+		this.comments = comments;
+		this.update({ comments: this.comments });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	setType(builder) {
+		this.type = builder(new DataFieldTypeFactory()).setContainer(this.node);
+		this.update({ type: this.type });
+		return this;
+	}
 };
 var DataFieldTypeFactory = class extends AstFactory {
-  static {
-    __name(this, "DataFieldTypeFactory");
-  }
-  array;
-  optional;
-  reference;
-  type;
-  unsupported;
-  constructor() {
-    super({
-      type: DataFieldType
-    });
-  }
-  setArray(array) {
-    this.array = array;
-    this.update({
-      array: this.array
-    });
-    return this;
-  }
-  setOptional(optional) {
-    this.optional = optional;
-    this.update({
-      optional: this.optional
-    });
-    return this;
-  }
-  setReference(reference) {
-    this.reference = {
-      $refText: reference.name,
-      ref: reference
-    };
-    this.update({
-      reference: this.reference
-    });
-    return this;
-  }
-  setType(type) {
-    this.type = type;
-    this.update({
-      type: this.type
-    });
-    return this;
-  }
-  setUnsupported(builder) {
-    this.unsupported = builder(new UnsupportedFieldTypeFactory()).setContainer(this.node);
-    this.update({
-      unsupported: this.unsupported
-    });
-    return this;
-  }
+	array;
+	optional;
+	reference;
+	type;
+	unsupported;
+	constructor() {
+		super({ type: require_ast.DataFieldType });
+	}
+	setArray(array) {
+		this.array = array;
+		this.update({ array: this.array });
+		return this;
+	}
+	setOptional(optional) {
+		this.optional = optional;
+		this.update({ optional: this.optional });
+		return this;
+	}
+	setReference(reference) {
+		this.reference = {
+			$refText: reference.name,
+			ref: reference
+		};
+		this.update({ reference: this.reference });
+		return this;
+	}
+	setType(type) {
+		this.type = type;
+		this.update({ type: this.type });
+		return this;
+	}
+	setUnsupported(builder) {
+		this.unsupported = builder(new UnsupportedFieldTypeFactory()).setContainer(this.node);
+		this.update({ unsupported: this.unsupported });
+		return this;
+	}
 };
 var UnsupportedFieldTypeFactory = class extends AstFactory {
-  static {
-    __name(this, "UnsupportedFieldTypeFactory");
-  }
-  value;
-  constructor() {
-    super({
-      type: UnsupportedFieldType
-    });
-  }
-  setValue(builder) {
-    this.value = builder(ExpressionBuilder());
-    this.update({
-      value: this.value
-    });
-    return this;
-  }
+	value;
+	constructor() {
+		super({ type: require_ast.UnsupportedFieldType });
+	}
+	setValue(builder) {
+		this.value = builder(ExpressionBuilder());
+		this.update({ value: this.value });
+		return this;
+	}
 };
 var ModelFactory = class extends AstFactory {
-  static {
-    __name(this, "ModelFactory");
-  }
-  declarations = [];
-  imports = [];
-  constructor() {
-    super({
-      type: Model,
-      node: {
-        declarations: [],
-        imports: []
-      }
-    });
-  }
-  addImport(builder) {
-    this.imports.push(builder(new ModelImportFactory()).setContainer(this.node));
-    this.update({
-      imports: this.imports
-    });
-    return this;
-  }
-  addDeclaration(builder) {
-    this.declarations.push(builder(DeclarationBuilder()).setContainer(this.node));
-    this.update({
-      declarations: this.declarations
-    });
-    return this;
-  }
+	declarations = [];
+	imports = [];
+	constructor() {
+		super({
+			type: require_ast.Model,
+			node: {
+				declarations: [],
+				imports: []
+			}
+		});
+	}
+	addImport(builder) {
+		this.imports.push(builder(new ModelImportFactory()).setContainer(this.node));
+		this.update({ imports: this.imports });
+		return this;
+	}
+	addDeclaration(builder) {
+		this.declarations.push(builder(DeclarationBuilder()).setContainer(this.node));
+		this.update({ declarations: this.declarations });
+		return this;
+	}
 };
 var ModelImportFactory = class extends AstFactory {
-  static {
-    __name(this, "ModelImportFactory");
-  }
-  path;
-  constructor() {
-    super({
-      type: ModelImport
-    });
-  }
-  setPath(path) {
-    this.path = path;
-    this.update({
-      path: this.path
-    });
-    return this;
-  }
+	path;
+	constructor() {
+		super({ type: require_ast.ModelImport });
+	}
+	setPath(path) {
+		this.path = path;
+		this.update({ path: this.path });
+		return this;
+	}
 };
 var EnumFactory = class extends AstFactory {
-  static {
-    __name(this, "EnumFactory");
-  }
-  name;
-  comments = [];
-  fields = [];
-  attributes = [];
-  constructor() {
-    super({
-      type: Enum,
-      node: {
-        comments: [],
-        fields: [],
-        attributes: []
-      }
-    });
-  }
-  addField(builder) {
-    this.fields.push(builder(new EnumFieldFactory()).setContainer(this.node));
-    this.update({
-      fields: this.fields
-    });
-    return this;
-  }
-  addAttribute(builder) {
-    this.attributes.push(builder(new DataModelAttributeFactory()).setContainer(this.node));
-    this.update({
-      attributes: this.attributes
-    });
-    return this;
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
+	name;
+	comments = [];
+	fields = [];
+	attributes = [];
+	constructor() {
+		super({
+			type: require_ast.Enum,
+			node: {
+				comments: [],
+				fields: [],
+				attributes: []
+			}
+		});
+	}
+	addField(builder) {
+		this.fields.push(builder(new EnumFieldFactory()).setContainer(this.node));
+		this.update({ fields: this.fields });
+		return this;
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new DataModelAttributeFactory()).setContainer(this.node));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
 };
 var EnumFieldFactory = class extends AstFactory {
-  static {
-    __name(this, "EnumFieldFactory");
-  }
-  name;
-  comments = [];
-  attributes = [];
-  constructor() {
-    super({
-      type: EnumField,
-      node: {
-        comments: [],
-        attributes: []
-      }
-    });
-  }
-  setName(name) {
-    this.name = name;
-    this.update({
-      name: this.name
-    });
-    return this;
-  }
-  addAttribute(builder) {
-    this.attributes.push(builder(new DataFieldAttributeFactory()).setContainer(this.node));
-    this.update({
-      attributes: this.attributes
-    });
-    return this;
-  }
-  addComment(comment) {
-    this.comments.push(comment);
-    this.update({
-      comments: this.comments
-    });
-    return this;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ArgumentFactory,
-  ArrayExprFactory,
-  AstFactory,
-  AttributeArgFactory,
-  AttributeFactory,
-  AttributeParamFactory,
-  AttributeParamTypeFactory,
-  BinaryExprFactory,
-  BooleanLiteralFactory,
-  DataFieldAttributeFactory,
-  DataFieldFactory,
-  DataFieldTypeFactory,
-  DataModelAttributeFactory,
-  DataModelFactory,
-  DeclarationBuilder,
-  EnumFactory,
-  EnumFieldFactory,
-  ExpressionBuilder,
-  FieldInitializerFactory,
-  InternalAttributeFactory,
-  InvocationExprFactory,
-  MemberAccessExprFactory,
-  ModelFactory,
-  ModelImportFactory,
-  NullExprFactory,
-  NumberLiteralFactory,
-  ObjectExprFactory,
-  ReferenceArgFactory,
-  ReferenceExprFactory,
-  StringLiteralFactory,
-  ThisExprFactory,
-  UnaryExprFactory,
-  UnsupportedFieldTypeFactory
-});
+	name;
+	comments = [];
+	attributes = [];
+	constructor() {
+		super({
+			type: require_ast.EnumField,
+			node: {
+				comments: [],
+				attributes: []
+			}
+		});
+	}
+	setName(name) {
+		this.name = name;
+		this.update({ name: this.name });
+		return this;
+	}
+	addAttribute(builder) {
+		this.attributes.push(builder(new DataFieldAttributeFactory()).setContainer(this.node));
+		this.update({ attributes: this.attributes });
+		return this;
+	}
+	addComment(comment) {
+		this.comments.push(comment);
+		this.update({ comments: this.comments });
+		return this;
+	}
+};
+//#endregion
+exports.ArgumentFactory = ArgumentFactory;
+exports.ArrayExprFactory = ArrayExprFactory;
+exports.AstFactory = AstFactory;
+exports.AttributeArgFactory = AttributeArgFactory;
+exports.AttributeFactory = AttributeFactory;
+exports.AttributeParamFactory = AttributeParamFactory;
+exports.AttributeParamTypeFactory = AttributeParamTypeFactory;
+exports.BinaryExprFactory = BinaryExprFactory;
+exports.BooleanLiteralFactory = BooleanLiteralFactory;
+exports.DataFieldAttributeFactory = DataFieldAttributeFactory;
+exports.DataFieldFactory = DataFieldFactory;
+exports.DataFieldTypeFactory = DataFieldTypeFactory;
+exports.DataModelAttributeFactory = DataModelAttributeFactory;
+exports.DataModelFactory = DataModelFactory;
+exports.DeclarationBuilder = DeclarationBuilder;
+exports.EnumFactory = EnumFactory;
+exports.EnumFieldFactory = EnumFieldFactory;
+exports.ExpressionBuilder = ExpressionBuilder;
+exports.FieldInitializerFactory = FieldInitializerFactory;
+exports.InternalAttributeFactory = InternalAttributeFactory;
+exports.InvocationExprFactory = InvocationExprFactory;
+exports.MemberAccessExprFactory = MemberAccessExprFactory;
+exports.ModelFactory = ModelFactory;
+exports.ModelImportFactory = ModelImportFactory;
+exports.NullExprFactory = NullExprFactory;
+exports.NumberLiteralFactory = NumberLiteralFactory;
+exports.ObjectExprFactory = ObjectExprFactory;
+exports.ReferenceArgFactory = ReferenceArgFactory;
+exports.ReferenceExprFactory = ReferenceExprFactory;
+exports.StringLiteralFactory = StringLiteralFactory;
+exports.ThisExprFactory = ThisExprFactory;
+exports.UnaryExprFactory = UnaryExprFactory;
+exports.UnsupportedFieldTypeFactory = UnsupportedFieldTypeFactory;
+
 //# sourceMappingURL=factory.cjs.map