@zenstackhq/language 3.3.2 → 3.4.0-beta.1

package/dist/factory.cjs

@@ -0,0 +1,2087 @@
+"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
+var ThisExprFactory = class extends AstFactory {
+  static {
+    __name(this, "ThisExprFactory");
+  }
+  constructor() {
+    super({
+      type: ThisExpr,
+      node: {
+        value: "this"
+      }
+    });
+  }
+};
+var NullExprFactory = class extends AstFactory {
+  static {
+    __name(this, "NullExprFactory");
+  }
+  constructor() {
+    super({
+      type: 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;
+  }
+};
+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;
+  }
+};
+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");
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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");
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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
+});
+//# sourceMappingURL=factory.cjs.map