@zenstackhq/language 3.5.6 → 3.6.0

package/dist/factory.d.cts

@@ -1,284 +1,289 @@
-import { BooleanLiteral, NullExpr, NumberLiteral, StringLiteral, ThisExpr, Argument, Expression, ArrayExpr, BinaryExpr, InvocationExpr, FunctionDecl, MemberAccessExpr, MemberAccessTarget, ObjectExpr, FieldInitializer, RegularID, ReferenceExpr, ReferenceTarget, ReferenceArg, UnaryExpr, AttributeArg, Attribute, InternalAttribute, AttributeParam, AttributeParamType, TypeDeclaration, DataFieldAttribute, DataModelAttribute, DataField, DataFieldType, BuiltinType, UnsupportedFieldType, LiteralExpr, DataModel, TypeDef, Enum, EnumField, RegularIDWithTypeNames, AbstractDeclaration, Model, ModelImport } from './ast.cjs';
-import { AstNode, Reference } from 'langium';
+import { $ as ReferenceArg, A as Enum, B as InvocationExpr, D as DataModel, E as DataFieldType, F as FunctionDecl, G as ModelImport, H as MemberAccessExpr, J as ObjectExpr, K as NullExpr, M as Expression, O as DataModelAttribute, P as FieldInitializer, T as DataFieldAttribute, U as MemberAccessTarget, V as LiteralExpr, W as Model, _ as BuiltinType, at as ThisExpr, c as Argument, ct as UnaryExpr, d as AttributeArg, et as ReferenceExpr, f as AttributeParam, g as BooleanLiteral, i as Reference$1, it as StringLiteral, j as EnumField, l as ArrayExpr, lt as UnsupportedFieldType, m as BinaryExpr, nt as RegularID, ot as TypeDeclaration, p as AttributeParamType, q as NumberLiteral, rt as RegularIDWithTypeNames, s as AbstractDeclaration, st as TypeDef, t as AstNode$1, tt as ReferenceTarget, u as Attribute, w as DataField, z as InternalAttribute } from "./ast-W2h6Qtfk.cjs";
+import { Reference } from "langium";
 
-type ContainerProps<T extends AstNode | undefined> = {
-    $container: T;
-    $containerProperty?: string;
-    $containerIndex?: number;
+//#region src/factory/ast-factory.d.ts
+type ContainerProps<T extends AstNode$1 | undefined> = {
+  $container: T;
+  $containerProperty?: string;
+  $containerIndex?: number;
 };
-type NodeFactoriesFor<N> = {
-    [K in keyof N as {} extends Pick<N, K> ? never : K]: N[K] extends (infer U)[] ? (AstFactory<U extends AstNode ? U : AstNode> | U)[] : AstFactory<N[K] extends AstNode ? N[K] : AstNode> | N[K];
-} & {
-    [K in keyof N as {} extends Pick<N, K> ? K : never]?: N[K] extends (infer U)[] ? (AstFactory<U extends AstNode ? U : AstNode> | U)[] : AstFactory<N[K] extends AstNode ? N[K] : AstNode> | N[K];
-};
-declare abstract class AstFactory<T extends AstNode = AstNode> {
-    node: T;
-    constructor({ type, node }: {
-        type: T['$type'];
-        node?: Partial<T>;
-    });
-    setContainer(container: T['$container']): this;
-    get(params?: ContainerProps<T['$container']>): T;
-    update(nodeArg: Partial<T | NodeFactoriesFor<T>>): T;
+type NodeFactoriesFor<N> = { [K in keyof N as {} extends Pick<N, K> ? never : K]: N[K] extends (infer U)[] ? (AstFactory<U extends AstNode$1 ? U : AstNode$1> | U)[] : AstFactory<N[K] extends AstNode$1 ? N[K] : AstNode$1> | N[K] } & { [K in keyof N as {} extends Pick<N, K> ? K : never]?: N[K] extends (infer U)[] ? (AstFactory<U extends AstNode$1 ? U : AstNode$1> | U)[] : AstFactory<N[K] extends AstNode$1 ? N[K] : AstNode$1> | N[K] };
+declare abstract class AstFactory<T extends AstNode$1 = AstNode$1> {
+  node: T;
+  constructor({
+    type,
+    node
+  }: {
+    type: T['$type'];
+    node?: Partial<T>;
+  });
+  setContainer(container: T['$container']): this;
+  get(params?: ContainerProps<T['$container']>): T;
+  update(nodeArg: Partial<T | NodeFactoriesFor<T>>): T;
 }
-
+//#endregion
+//#region src/factory/primitives.d.ts
 declare class ThisExprFactory extends AstFactory<ThisExpr> {
-    constructor();
+  constructor();
 }
 declare class NullExprFactory extends AstFactory<NullExpr> {
-    constructor();
+  constructor();
 }
 declare class NumberLiteralFactory extends AstFactory<NumberLiteral> {
-    value?: number | string;
-    constructor();
-    setValue(value: number | string): this;
+  value?: number | string;
+  constructor();
+  setValue(value: number | string): this;
 }
 declare class StringLiteralFactory extends AstFactory<StringLiteral> {
-    value?: string;
-    constructor();
-    setValue(value: string): this;
+  value?: string;
+  constructor();
+  setValue(value: string): this;
 }
 declare class BooleanLiteralFactory extends AstFactory<BooleanLiteral> {
-    value?: boolean;
-    constructor();
-    setValue(value: boolean): this;
+  value?: boolean;
+  constructor();
+  setValue(value: boolean): this;
 }
-
-type ExpressionFactoryMap = ReturnType<typeof ExpressionBuilder>;
+//#endregion
+//#region src/factory/expression.d.ts
 declare const ExpressionBuilder: () => {
-    readonly ArrayExpr: ArrayExprFactory;
-    readonly BinaryExpr: BinaryExprFactory;
-    readonly BooleanLiteral: BooleanLiteralFactory;
-    readonly InvocationExpr: InvocationExprFactory;
-    readonly MemberAccessExpr: MemberAccessExprFactory;
-    readonly NullExpr: NullExprFactory;
-    readonly NumberLiteral: NumberLiteralFactory;
-    readonly ObjectExpr: ObjectExprFactory;
-    readonly ReferenceExpr: ReferenceExprFactory;
-    readonly StringLiteral: StringLiteralFactory;
-    readonly ThisExpr: ThisExprFactory;
-    readonly UnaryExpr: UnaryExprFactory;
+  readonly ArrayExpr: ArrayExprFactory;
+  readonly BinaryExpr: BinaryExprFactory;
+  readonly BooleanLiteral: BooleanLiteralFactory;
+  readonly InvocationExpr: InvocationExprFactory;
+  readonly MemberAccessExpr: MemberAccessExprFactory;
+  readonly NullExpr: NullExprFactory;
+  readonly NumberLiteral: NumberLiteralFactory;
+  readonly ObjectExpr: ObjectExprFactory;
+  readonly ReferenceExpr: ReferenceExprFactory;
+  readonly StringLiteral: StringLiteralFactory;
+  readonly ThisExpr: ThisExprFactory;
+  readonly UnaryExpr: UnaryExprFactory;
 };
+type ExpressionFactoryMap = ReturnType<typeof ExpressionBuilder>;
 type ExpressionBuilder<T extends Expression = Expression> = Pick<ExpressionFactoryMap, Extract<T['$type'], keyof ExpressionFactoryMap>>;
 declare class UnaryExprFactory extends AstFactory<UnaryExpr> {
-    operand?: AstFactory<Expression>;
-    constructor();
-    setOperand(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+  operand?: AstFactory<Expression>;
+  constructor();
+  setOperand(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class ReferenceExprFactory extends AstFactory<ReferenceExpr> {
-    target?: Reference<ReferenceTarget>;
-    args: ReferenceArgFactory[];
-    constructor();
-    setTarget(target: ReferenceTarget): this;
-    addArg(builder: (a: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+  target?: Reference<ReferenceTarget>;
+  args: ReferenceArgFactory[];
+  constructor();
+  setTarget(target: ReferenceTarget): this;
+  addArg(builder: (a: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
 }
 declare class ReferenceArgFactory extends AstFactory<ReferenceArg> {
-    name?: string;
-    value?: AstFactory<Expression>;
-    constructor();
-    setName(name: string): this;
-    setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+  name?: string;
+  value?: AstFactory<Expression>;
+  constructor();
+  setName(name: string): this;
+  setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class MemberAccessExprFactory extends AstFactory<MemberAccessExpr> {
-    member?: Reference<MemberAccessTarget>;
-    operand?: AstFactory<Expression>;
-    constructor();
-    setMember(target: Reference<MemberAccessTarget>): this;
-    setOperand(builder: (b: ExpressionBuilder) => AstFactory<Expression>): this;
+  member?: Reference<MemberAccessTarget>;
+  operand?: AstFactory<Expression>;
+  constructor();
+  setMember(target: Reference<MemberAccessTarget>): this;
+  setOperand(builder: (b: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class ObjectExprFactory extends AstFactory<ObjectExpr> {
-    fields: FieldInitializerFactory[];
-    constructor();
-    addField(builder: (b: FieldInitializerFactory) => FieldInitializerFactory): this;
+  fields: FieldInitializerFactory[];
+  constructor();
+  addField(builder: (b: FieldInitializerFactory) => FieldInitializerFactory): this;
 }
 declare class FieldInitializerFactory extends AstFactory<FieldInitializer> {
-    name?: RegularID;
-    value?: AstFactory<Expression>;
-    constructor();
-    setName(name: RegularID): this;
-    setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+  name?: RegularID;
+  value?: AstFactory<Expression>;
+  constructor();
+  setName(name: RegularID): this;
+  setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class InvocationExprFactory extends AstFactory<InvocationExpr> {
-    args: ArgumentFactory[];
-    function?: Reference<FunctionDecl>;
-    constructor();
-    addArg(builder: (arg: ArgumentFactory) => ArgumentFactory): this;
-    setFunction(value: FunctionDecl): this;
+  args: ArgumentFactory[];
+  function?: Reference<FunctionDecl>;
+  constructor();
+  addArg(builder: (arg: ArgumentFactory) => ArgumentFactory): this;
+  setFunction(value: FunctionDecl): this;
 }
 declare class ArgumentFactory extends AstFactory<Argument> {
-    value?: AstFactory<Expression>;
-    constructor();
-    setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+  value?: AstFactory<Expression>;
+  constructor();
+  setValue(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class ArrayExprFactory extends AstFactory<ArrayExpr> {
-    items: AstFactory<Expression>[];
-    constructor();
-    addItem(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
+  items: AstFactory<Expression>[];
+  constructor();
+  addItem(builder: (a: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class BinaryExprFactory extends AstFactory<BinaryExpr> {
-    operator?: BinaryExpr['operator'];
-    right?: AstFactory<Expression>;
-    left?: AstFactory<Expression>;
-    constructor();
-    setOperator(operator: BinaryExpr['operator']): this;
-    setRight(builder: (arg: ExpressionBuilder) => AstFactory<Expression>): this;
-    setLeft(builder: (arg: ExpressionBuilder) => AstFactory<Expression>): this;
+  operator?: BinaryExpr['operator'];
+  right?: AstFactory<Expression>;
+  left?: AstFactory<Expression>;
+  constructor();
+  setOperator(operator: BinaryExpr['operator']): this;
+  setRight(builder: (arg: ExpressionBuilder) => AstFactory<Expression>): this;
+  setLeft(builder: (arg: ExpressionBuilder) => AstFactory<Expression>): this;
 }
-
+//#endregion
+//#region src/factory/attribute.d.ts
 declare class DataFieldAttributeFactory extends AstFactory<DataFieldAttribute> {
-    args: AttributeArgFactory[];
-    decl?: Reference<Attribute>;
-    constructor();
-    setDecl(decl: Attribute): this;
-    addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+  args: AttributeArgFactory[];
+  decl?: Reference$1<Attribute>;
+  constructor();
+  setDecl(decl: Attribute): this;
+  addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
 }
 declare class DataModelAttributeFactory extends AstFactory<DataModelAttribute> {
-    args: AttributeArgFactory[];
-    decl?: Reference<Attribute>;
-    constructor();
-    setDecl(decl: Attribute): this;
-    addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+  args: AttributeArgFactory[];
+  decl?: Reference$1<Attribute>;
+  constructor();
+  setDecl(decl: Attribute): this;
+  addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
 }
 declare class AttributeArgFactory extends AstFactory<AttributeArg> {
-    name?: RegularID;
-    value?: AstFactory<Expression>;
-    constructor();
-    setName(name: RegularID): this;
-    setValue(builder: (b: ExpressionBuilder) => AstFactory<Expression>): this;
+  name?: RegularID;
+  value?: AstFactory<Expression>;
+  constructor();
+  setName(name: RegularID): this;
+  setValue(builder: (b: ExpressionBuilder) => AstFactory<Expression>): this;
 }
 declare class InternalAttributeFactory extends AstFactory<InternalAttribute> {
-    decl?: Reference<Attribute>;
-    args: AttributeArgFactory[];
-    constructor();
-    setDecl(decl: Attribute): this;
-    addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
+  decl?: Reference$1<Attribute>;
+  args: AttributeArgFactory[];
+  constructor();
+  setDecl(decl: Attribute): this;
+  addArg(builder: (b: ExpressionBuilder) => AstFactory<Expression>, name?: string): this;
 }
 declare class AttributeParamFactory extends AstFactory<AttributeParam> {
-    attributes: InternalAttributeFactory[];
-    comments: string[];
-    default?: boolean;
-    name?: RegularID;
-    type?: AttributeParamTypeFactory;
-    constructor();
-    addAttribute(builder: (b: InternalAttributeFactory) => InternalAttributeFactory): this;
-    setComments(comments: string[]): this;
-    setDefault(defaultValue: boolean): this;
-    setName(name: string): this;
-    setType(builder: (b: AttributeParamTypeFactory) => AttributeParamTypeFactory): this;
+  attributes: InternalAttributeFactory[];
+  comments: string[];
+  default?: boolean;
+  name?: RegularID;
+  type?: AttributeParamTypeFactory;
+  constructor();
+  addAttribute(builder: (b: InternalAttributeFactory) => InternalAttributeFactory): this;
+  setComments(comments: string[]): this;
+  setDefault(defaultValue: boolean): this;
+  setName(name: string): this;
+  setType(builder: (b: AttributeParamTypeFactory) => AttributeParamTypeFactory): this;
 }
 declare class AttributeParamTypeFactory extends AstFactory<AttributeParamType> {
-    array?: boolean;
-    optional?: boolean;
-    reference?: Reference<TypeDeclaration>;
-    type?: AttributeParamType['type'];
-    constructor();
-    setArray(array: boolean): this;
-    setOptional(optional: boolean): this;
-    setReference(reference: TypeDeclaration): this;
-    setType(type: AttributeParamType['type']): this;
+  array?: boolean;
+  optional?: boolean;
+  reference?: Reference$1<TypeDeclaration>;
+  type?: AttributeParamType['type'];
+  constructor();
+  setArray(array: boolean): this;
+  setOptional(optional: boolean): this;
+  setReference(reference: TypeDeclaration): this;
+  setType(type: AttributeParamType['type']): this;
 }
 declare class AttributeFactory extends AstFactory<Attribute> {
-    name?: string;
-    comments: string[];
-    attributes: InternalAttributeFactory[];
-    params: AttributeParamFactory[];
-    constructor();
-    setName(name: string): this;
-    setComments(comments: string[]): this;
-    addAttribute(builder: (b: InternalAttributeFactory) => InternalAttributeFactory): this;
-    addParam(builder: (b: AttributeParamFactory) => AttributeParamFactory): this;
+  name?: string;
+  comments: string[];
+  attributes: InternalAttributeFactory[];
+  params: AttributeParamFactory[];
+  constructor();
+  setName(name: string): this;
+  setComments(comments: string[]): this;
+  addAttribute(builder: (b: InternalAttributeFactory) => InternalAttributeFactory): this;
+  addParam(builder: (b: AttributeParamFactory) => AttributeParamFactory): this;
 }
-
-type DeclarationBuilderMap = ReturnType<typeof DeclarationBuilder>;
+//#endregion
+//#region src/factory/declaration.d.ts
 declare const DeclarationBuilder: () => {
-    readonly Attribute: AttributeFactory;
-    readonly DataModel: DataModelFactory;
-    readonly DataSource: any;
-    readonly Enum: EnumFactory;
-    readonly FunctionDecl: any;
-    readonly GeneratorDecl: any;
-    readonly Plugin: any;
-    readonly Procedure: any;
-    readonly TypeDef: any;
+  readonly Attribute: AttributeFactory;
+  readonly DataModel: DataModelFactory;
+  readonly DataSource: any;
+  readonly Enum: EnumFactory;
+  readonly FunctionDecl: any;
+  readonly GeneratorDecl: any;
+  readonly Plugin: any;
+  readonly Procedure: any;
+  readonly TypeDef: any;
 };
+type DeclarationBuilderMap = ReturnType<typeof DeclarationBuilder>;
 type DeclarationBuilder<T extends AbstractDeclaration = AbstractDeclaration> = Pick<DeclarationBuilderMap, Extract<T['$type'], keyof DeclarationBuilderMap>>;
 declare class DataModelFactory extends AstFactory<DataModel> {
-    attributes: DataModelAttributeFactory[];
-    baseModel?: Reference<DataModel>;
-    comments: string[];
-    fields: DataFieldFactory[];
-    isView?: boolean;
-    mixins: Reference<TypeDef>[];
-    name?: RegularID;
-    constructor();
-    addAttribute(builder: (attr: DataModelAttributeFactory) => DataModelAttributeFactory): this;
-    setBaseModel(model: Reference<DataModel>): this;
-    setComments(comments: string[]): this;
-    addComment(comment: string): this;
-    addField(builder: (field: DataFieldFactory) => DataFieldFactory): this;
-    setIsView(isView: boolean): this;
-    addMixin(mixin: Reference<TypeDef>): this;
-    setName(name: string): this;
+  attributes: DataModelAttributeFactory[];
+  baseModel?: Reference$1<DataModel>;
+  comments: string[];
+  fields: DataFieldFactory[];
+  isView?: boolean;
+  mixins: Reference$1<TypeDef>[];
+  name?: RegularID;
+  constructor();
+  addAttribute(builder: (attr: DataModelAttributeFactory) => DataModelAttributeFactory): this;
+  setBaseModel(model: Reference$1<DataModel>): this;
+  setComments(comments: string[]): this;
+  addComment(comment: string): this;
+  addField(builder: (field: DataFieldFactory) => DataFieldFactory): this;
+  setIsView(isView: boolean): this;
+  addMixin(mixin: Reference$1<TypeDef>): this;
+  setName(name: string): this;
 }
 declare class DataFieldFactory extends AstFactory<DataField> {
-    attributes: DataFieldAttributeFactory[];
-    comments: string[];
-    name?: string;
-    type?: DataFieldTypeFactory;
-    constructor();
-    addAttribute(builder: ((attr: DataFieldAttributeFactory) => DataFieldAttributeFactory) | DataFieldAttributeFactory): this;
-    setComments(comments: string[]): this;
-    setName(name: string): this;
-    setType(builder: (type: DataFieldTypeFactory) => DataFieldTypeFactory): this;
+  attributes: DataFieldAttributeFactory[];
+  comments: string[];
+  name?: string;
+  type?: DataFieldTypeFactory;
+  constructor();
+  addAttribute(builder: ((attr: DataFieldAttributeFactory) => DataFieldAttributeFactory) | DataFieldAttributeFactory): this;
+  setComments(comments: string[]): this;
+  setName(name: string): this;
+  setType(builder: (type: DataFieldTypeFactory) => DataFieldTypeFactory): this;
 }
 declare class DataFieldTypeFactory extends AstFactory<DataFieldType> {
-    array?: boolean;
-    optional?: boolean;
-    reference?: Reference<TypeDeclaration>;
-    type?: BuiltinType;
-    unsupported?: UnsupportedFieldTypeFactory;
-    constructor();
-    setArray(array: boolean): this;
-    setOptional(optional: boolean): this;
-    setReference(reference: TypeDeclaration): this;
-    setType(type: BuiltinType): this;
-    setUnsupported(builder: (a: UnsupportedFieldTypeFactory) => UnsupportedFieldTypeFactory): this;
+  array?: boolean;
+  optional?: boolean;
+  reference?: Reference$1<TypeDeclaration>;
+  type?: BuiltinType;
+  unsupported?: UnsupportedFieldTypeFactory;
+  constructor();
+  setArray(array: boolean): this;
+  setOptional(optional: boolean): this;
+  setReference(reference: TypeDeclaration): this;
+  setType(type: BuiltinType): this;
+  setUnsupported(builder: (a: UnsupportedFieldTypeFactory) => UnsupportedFieldTypeFactory): this;
 }
 declare class UnsupportedFieldTypeFactory extends AstFactory<UnsupportedFieldType> {
-    value?: AstFactory<LiteralExpr>;
-    constructor();
-    setValue(builder: (value: ExpressionBuilder<LiteralExpr>) => AstFactory<LiteralExpr>): this;
+  value?: AstFactory<LiteralExpr>;
+  constructor();
+  setValue(builder: (value: ExpressionBuilder<LiteralExpr>) => AstFactory<LiteralExpr>): this;
 }
 declare class ModelFactory extends AstFactory<Model> {
-    declarations: AstFactory<AbstractDeclaration>[];
-    imports: ModelImportFactory[];
-    constructor();
-    addImport(builder: (b: ModelImportFactory) => ModelImportFactory): this;
-    addDeclaration(builder: (b: DeclarationBuilder) => AstFactory<AbstractDeclaration>): this;
+  declarations: AstFactory<AbstractDeclaration>[];
+  imports: ModelImportFactory[];
+  constructor();
+  addImport(builder: (b: ModelImportFactory) => ModelImportFactory): this;
+  addDeclaration(builder: (b: DeclarationBuilder) => AstFactory<AbstractDeclaration>): this;
 }
 declare class ModelImportFactory extends AstFactory<ModelImport> {
-    path?: string | undefined;
-    constructor();
-    setPath(path: string): this;
+  path?: string | undefined;
+  constructor();
+  setPath(path: string): this;
 }
 declare class EnumFactory extends AstFactory<Enum> {
-    name?: string;
-    comments: string[];
-    fields: EnumFieldFactory[];
-    attributes: DataModelAttributeFactory[];
-    constructor();
-    addField(builder: (b: EnumFieldFactory) => EnumFieldFactory): this;
-    addAttribute(builder: (b: DataModelAttributeFactory) => DataModelAttributeFactory): this;
-    setName(name: string): this;
+  name?: string;
+  comments: string[];
+  fields: EnumFieldFactory[];
+  attributes: DataModelAttributeFactory[];
+  constructor();
+  addField(builder: (b: EnumFieldFactory) => EnumFieldFactory): this;
+  addAttribute(builder: (b: DataModelAttributeFactory) => DataModelAttributeFactory): this;
+  setName(name: string): this;
 }
 declare class EnumFieldFactory extends AstFactory<EnumField> {
-    name?: RegularIDWithTypeNames;
-    comments: string[];
-    attributes: DataFieldAttributeFactory[];
-    constructor();
-    setName(name: RegularIDWithTypeNames): this;
-    addAttribute(builder: (b: DataFieldAttributeFactory) => DataFieldAttributeFactory): this;
-    addComment(comment: string): this;
+  name?: RegularIDWithTypeNames;
+  comments: string[];
+  attributes: DataFieldAttributeFactory[];
+  constructor();
+  setName(name: RegularIDWithTypeNames): this;
+  addAttribute(builder: (b: DataFieldAttributeFactory) => DataFieldAttributeFactory): this;
+  addComment(comment: string): this;
 }
-
-export { ArgumentFactory, ArrayExprFactory, AstFactory, AttributeArgFactory, AttributeFactory, AttributeParamFactory, AttributeParamTypeFactory, BinaryExprFactory, BooleanLiteralFactory, type ContainerProps, DataFieldAttributeFactory, DataFieldFactory, DataFieldTypeFactory, DataModelAttributeFactory, DataModelFactory, DeclarationBuilder, EnumFactory, EnumFieldFactory, ExpressionBuilder, FieldInitializerFactory, InternalAttributeFactory, InvocationExprFactory, MemberAccessExprFactory, ModelFactory, ModelImportFactory, NullExprFactory, NumberLiteralFactory, ObjectExprFactory, ReferenceArgFactory, ReferenceExprFactory, StringLiteralFactory, ThisExprFactory, UnaryExprFactory, UnsupportedFieldTypeFactory };
+//#endregion
+export { ArgumentFactory, ArrayExprFactory, AstFactory, AttributeArgFactory, AttributeFactory, AttributeParamFactory, AttributeParamTypeFactory, BinaryExprFactory, BooleanLiteralFactory, ContainerProps, 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.d.cts.map