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

package/dist/ast-DHvua30v.cjs

@@ -0,0 +1,1721 @@
+//#region \0rolldown/runtime.js
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let langium = require("langium");
+langium = __toESM(langium, 1);
+//#region src/generated/ast.ts
+/******************************************************************************
+* This file was generated by langium-cli 4.2.1.
+* DO NOT EDIT MANUALLY!
+******************************************************************************/
+const ZModelTerminals = {
+	WS: /\s+/,
+	INTERNAL_ATTRIBUTE_NAME: /@@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
+	MODEL_ATTRIBUTE_NAME: /@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
+	FIELD_ATTRIBUTE_NAME: /@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
+	ID: /[_a-zA-Z][\w_]*/,
+	STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+	NUMBER: /[+-]?[0-9]+(\.[0-9]+)?/,
+	TRIPLE_SLASH_COMMENT: /\/\/\/[^\n\r]*/,
+	ML_COMMENT: /\/\*[\s\S]*?\*\//,
+	SL_COMMENT: /\/\/[^\n\r]*/
+};
+const AbstractDeclaration = { $type: "AbstractDeclaration" };
+function isAbstractDeclaration(item) {
+	return reflection.isInstance(item, AbstractDeclaration.$type);
+}
+const Argument = {
+	$type: "Argument",
+	value: "value"
+};
+function isArgument(item) {
+	return reflection.isInstance(item, Argument.$type);
+}
+const ArrayExpr = {
+	$type: "ArrayExpr",
+	items: "items"
+};
+function isArrayExpr(item) {
+	return reflection.isInstance(item, ArrayExpr.$type);
+}
+const Attribute = {
+	$type: "Attribute",
+	attributes: "attributes",
+	comments: "comments",
+	name: "name",
+	params: "params"
+};
+function isAttribute(item) {
+	return reflection.isInstance(item, Attribute.$type);
+}
+const AttributeArg = {
+	$type: "AttributeArg",
+	name: "name",
+	value: "value"
+};
+function isAttributeArg(item) {
+	return reflection.isInstance(item, AttributeArg.$type);
+}
+const AttributeParam = {
+	$type: "AttributeParam",
+	attributes: "attributes",
+	comments: "comments",
+	default: "default",
+	name: "name",
+	type: "type"
+};
+function isAttributeParam(item) {
+	return reflection.isInstance(item, AttributeParam.$type);
+}
+const AttributeParamType = {
+	$type: "AttributeParamType",
+	array: "array",
+	optional: "optional",
+	reference: "reference",
+	type: "type"
+};
+function isAttributeParamType(item) {
+	return reflection.isInstance(item, AttributeParamType.$type);
+}
+const BinaryExpr = {
+	$type: "BinaryExpr",
+	binding: "binding",
+	left: "left",
+	operator: "operator",
+	right: "right"
+};
+function isBinaryExpr(item) {
+	return reflection.isInstance(item, BinaryExpr.$type);
+}
+function isBoolean(item) {
+	return typeof item === "boolean";
+}
+const BooleanLiteral = {
+	$type: "BooleanLiteral",
+	value: "value"
+};
+function isBooleanLiteral(item) {
+	return reflection.isInstance(item, BooleanLiteral.$type);
+}
+function isBuiltinType(item) {
+	return item === "String" || item === "Boolean" || item === "Int" || item === "BigInt" || item === "Float" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes";
+}
+const CollectionPredicateBinding = {
+	$type: "CollectionPredicateBinding",
+	name: "name"
+};
+function isCollectionPredicateBinding(item) {
+	return reflection.isInstance(item, CollectionPredicateBinding.$type);
+}
+const ConfigArrayExpr = {
+	$type: "ConfigArrayExpr",
+	items: "items"
+};
+function isConfigArrayExpr(item) {
+	return reflection.isInstance(item, ConfigArrayExpr.$type);
+}
+const ConfigExpr = { $type: "ConfigExpr" };
+function isConfigExpr(item) {
+	return reflection.isInstance(item, ConfigExpr.$type);
+}
+const ConfigField = {
+	$type: "ConfigField",
+	name: "name",
+	value: "value"
+};
+function isConfigField(item) {
+	return reflection.isInstance(item, ConfigField.$type);
+}
+const ConfigInvocationArg = {
+	$type: "ConfigInvocationArg",
+	name: "name",
+	value: "value"
+};
+function isConfigInvocationArg(item) {
+	return reflection.isInstance(item, ConfigInvocationArg.$type);
+}
+const ConfigInvocationExpr = {
+	$type: "ConfigInvocationExpr",
+	args: "args",
+	name: "name"
+};
+function isConfigInvocationExpr(item) {
+	return reflection.isInstance(item, ConfigInvocationExpr.$type);
+}
+const DataField = {
+	$type: "DataField",
+	attributes: "attributes",
+	comments: "comments",
+	name: "name",
+	type: "type"
+};
+function isDataField(item) {
+	return reflection.isInstance(item, DataField.$type);
+}
+const DataFieldAttribute = {
+	$type: "DataFieldAttribute",
+	args: "args",
+	decl: "decl"
+};
+function isDataFieldAttribute(item) {
+	return reflection.isInstance(item, DataFieldAttribute.$type);
+}
+const DataFieldType = {
+	$type: "DataFieldType",
+	array: "array",
+	optional: "optional",
+	reference: "reference",
+	type: "type",
+	unsupported: "unsupported"
+};
+function isDataFieldType(item) {
+	return reflection.isInstance(item, DataFieldType.$type);
+}
+const DataModel = {
+	$type: "DataModel",
+	attributes: "attributes",
+	baseModel: "baseModel",
+	comments: "comments",
+	fields: "fields",
+	isView: "isView",
+	mixins: "mixins",
+	name: "name"
+};
+function isDataModel(item) {
+	return reflection.isInstance(item, DataModel.$type);
+}
+const DataModelAttribute = {
+	$type: "DataModelAttribute",
+	args: "args",
+	decl: "decl"
+};
+function isDataModelAttribute(item) {
+	return reflection.isInstance(item, DataModelAttribute.$type);
+}
+const DataSource = {
+	$type: "DataSource",
+	fields: "fields",
+	name: "name"
+};
+function isDataSource(item) {
+	return reflection.isInstance(item, DataSource.$type);
+}
+const Enum = {
+	$type: "Enum",
+	attributes: "attributes",
+	comments: "comments",
+	fields: "fields",
+	name: "name"
+};
+function isEnum(item) {
+	return reflection.isInstance(item, Enum.$type);
+}
+const EnumField = {
+	$type: "EnumField",
+	attributes: "attributes",
+	comments: "comments",
+	name: "name"
+};
+function isEnumField(item) {
+	return reflection.isInstance(item, EnumField.$type);
+}
+const Expression = { $type: "Expression" };
+function isExpression(item) {
+	return reflection.isInstance(item, Expression.$type);
+}
+function isExpressionType(item) {
+	return item === "String" || item === "Int" || item === "Float" || item === "Boolean" || item === "BigInt" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes" || item === "Null" || item === "Object" || item === "Any" || item === "Void" || item === "Undefined" || item === "Unsupported";
+}
+const FieldInitializer = {
+	$type: "FieldInitializer",
+	name: "name",
+	value: "value"
+};
+function isFieldInitializer(item) {
+	return reflection.isInstance(item, FieldInitializer.$type);
+}
+const FunctionDecl = {
+	$type: "FunctionDecl",
+	attributes: "attributes",
+	expression: "expression",
+	name: "name",
+	params: "params",
+	returnType: "returnType"
+};
+function isFunctionDecl(item) {
+	return reflection.isInstance(item, FunctionDecl.$type);
+}
+const FunctionParam = {
+	$type: "FunctionParam",
+	name: "name",
+	optional: "optional",
+	type: "type"
+};
+function isFunctionParam(item) {
+	return reflection.isInstance(item, FunctionParam.$type);
+}
+const FunctionParamType = {
+	$type: "FunctionParamType",
+	array: "array",
+	reference: "reference",
+	type: "type"
+};
+function isFunctionParamType(item) {
+	return reflection.isInstance(item, FunctionParamType.$type);
+}
+const GeneratorDecl = {
+	$type: "GeneratorDecl",
+	fields: "fields",
+	name: "name"
+};
+function isGeneratorDecl(item) {
+	return reflection.isInstance(item, GeneratorDecl.$type);
+}
+const InternalAttribute = {
+	$type: "InternalAttribute",
+	args: "args",
+	decl: "decl"
+};
+function isInternalAttribute(item) {
+	return reflection.isInstance(item, InternalAttribute.$type);
+}
+const InvocationExpr = {
+	$type: "InvocationExpr",
+	args: "args",
+	function: "function"
+};
+function isInvocationExpr(item) {
+	return reflection.isInstance(item, InvocationExpr.$type);
+}
+const LiteralExpr = { $type: "LiteralExpr" };
+function isLiteralExpr(item) {
+	return reflection.isInstance(item, LiteralExpr.$type);
+}
+const MemberAccessExpr = {
+	$type: "MemberAccessExpr",
+	member: "member",
+	operand: "operand"
+};
+function isMemberAccessExpr(item) {
+	return reflection.isInstance(item, MemberAccessExpr.$type);
+}
+const MemberAccessTarget = { $type: "MemberAccessTarget" };
+function isMemberAccessTarget(item) {
+	return reflection.isInstance(item, MemberAccessTarget.$type);
+}
+const Model = {
+	$type: "Model",
+	declarations: "declarations",
+	imports: "imports"
+};
+function isModel(item) {
+	return reflection.isInstance(item, Model.$type);
+}
+const ModelImport = {
+	$type: "ModelImport",
+	path: "path"
+};
+function isModelImport(item) {
+	return reflection.isInstance(item, ModelImport.$type);
+}
+const NullExpr = {
+	$type: "NullExpr",
+	value: "value"
+};
+function isNullExpr(item) {
+	return reflection.isInstance(item, NullExpr.$type);
+}
+const NumberLiteral = {
+	$type: "NumberLiteral",
+	value: "value"
+};
+function isNumberLiteral(item) {
+	return reflection.isInstance(item, NumberLiteral.$type);
+}
+const ObjectExpr = {
+	$type: "ObjectExpr",
+	fields: "fields"
+};
+function isObjectExpr(item) {
+	return reflection.isInstance(item, ObjectExpr.$type);
+}
+const Plugin = {
+	$type: "Plugin",
+	fields: "fields",
+	name: "name"
+};
+function isPlugin(item) {
+	return reflection.isInstance(item, Plugin.$type);
+}
+const PluginField = {
+	$type: "PluginField",
+	name: "name",
+	value: "value"
+};
+function isPluginField(item) {
+	return reflection.isInstance(item, PluginField.$type);
+}
+const Procedure = {
+	$type: "Procedure",
+	attributes: "attributes",
+	mutation: "mutation",
+	name: "name",
+	params: "params",
+	returnType: "returnType"
+};
+function isProcedure(item) {
+	return reflection.isInstance(item, Procedure.$type);
+}
+const ProcedureParam = {
+	$type: "ProcedureParam",
+	name: "name",
+	optional: "optional",
+	type: "type"
+};
+function isProcedureParam(item) {
+	return reflection.isInstance(item, ProcedureParam.$type);
+}
+const ReferenceArg = {
+	$type: "ReferenceArg",
+	name: "name",
+	value: "value"
+};
+function isReferenceArg(item) {
+	return reflection.isInstance(item, ReferenceArg.$type);
+}
+const ReferenceExpr = {
+	$type: "ReferenceExpr",
+	args: "args",
+	target: "target"
+};
+function isReferenceExpr(item) {
+	return reflection.isInstance(item, ReferenceExpr.$type);
+}
+const ReferenceTarget = { $type: "ReferenceTarget" };
+function isReferenceTarget(item) {
+	return reflection.isInstance(item, ReferenceTarget.$type);
+}
+function isRegularID(item) {
+	return item === "model" || item === "enum" || item === "attribute" || item === "datasource" || item === "plugin" || item === "abstract" || item === "in" || item === "view" || item === "import" || item === "type" || typeof item === "string" && /[_a-zA-Z][\w_]*/.test(item);
+}
+function isRegularIDWithTypeNames(item) {
+	return isRegularID(item) || item === "String" || item === "Boolean" || item === "Int" || item === "BigInt" || item === "Float" || item === "Decimal" || item === "DateTime" || item === "Json" || item === "Bytes" || item === "Null" || item === "Object" || item === "Any" || item === "Void" || item === "Unsupported";
+}
+const StringLiteral = {
+	$type: "StringLiteral",
+	value: "value"
+};
+function isStringLiteral(item) {
+	return reflection.isInstance(item, StringLiteral.$type);
+}
+const ThisExpr = {
+	$type: "ThisExpr",
+	value: "value"
+};
+function isThisExpr(item) {
+	return reflection.isInstance(item, ThisExpr.$type);
+}
+const TypeDeclaration = { $type: "TypeDeclaration" };
+function isTypeDeclaration(item) {
+	return reflection.isInstance(item, TypeDeclaration.$type);
+}
+const TypeDef = {
+	$type: "TypeDef",
+	attributes: "attributes",
+	comments: "comments",
+	fields: "fields",
+	mixins: "mixins",
+	name: "name"
+};
+function isTypeDef(item) {
+	return reflection.isInstance(item, TypeDef.$type);
+}
+const UnaryExpr = {
+	$type: "UnaryExpr",
+	operand: "operand",
+	operator: "operator"
+};
+function isUnaryExpr(item) {
+	return reflection.isInstance(item, UnaryExpr.$type);
+}
+const UnsupportedFieldType = {
+	$type: "UnsupportedFieldType",
+	value: "value"
+};
+function isUnsupportedFieldType(item) {
+	return reflection.isInstance(item, UnsupportedFieldType.$type);
+}
+var ZModelAstReflection = class extends langium.AbstractAstReflection {
+	types = {
+		AbstractDeclaration: {
+			name: AbstractDeclaration.$type,
+			properties: {},
+			superTypes: []
+		},
+		Argument: {
+			name: Argument.$type,
+			properties: { value: { name: Argument.value } },
+			superTypes: []
+		},
+		ArrayExpr: {
+			name: ArrayExpr.$type,
+			properties: { items: {
+				name: ArrayExpr.items,
+				defaultValue: []
+			} },
+			superTypes: [Expression.$type]
+		},
+		Attribute: {
+			name: Attribute.$type,
+			properties: {
+				attributes: {
+					name: Attribute.attributes,
+					defaultValue: []
+				},
+				comments: {
+					name: Attribute.comments,
+					defaultValue: []
+				},
+				name: { name: Attribute.name },
+				params: {
+					name: Attribute.params,
+					defaultValue: []
+				}
+			},
+			superTypes: [AbstractDeclaration.$type]
+		},
+		AttributeArg: {
+			name: AttributeArg.$type,
+			properties: {
+				name: { name: AttributeArg.name },
+				value: { name: AttributeArg.value }
+			},
+			superTypes: []
+		},
+		AttributeParam: {
+			name: AttributeParam.$type,
+			properties: {
+				attributes: {
+					name: AttributeParam.attributes,
+					defaultValue: []
+				},
+				comments: {
+					name: AttributeParam.comments,
+					defaultValue: []
+				},
+				default: {
+					name: AttributeParam.default,
+					defaultValue: false
+				},
+				name: { name: AttributeParam.name },
+				type: { name: AttributeParam.type }
+			},
+			superTypes: []
+		},
+		AttributeParamType: {
+			name: AttributeParamType.$type,
+			properties: {
+				array: {
+					name: AttributeParamType.array,
+					defaultValue: false
+				},
+				optional: {
+					name: AttributeParamType.optional,
+					defaultValue: false
+				},
+				reference: {
+					name: AttributeParamType.reference,
+					referenceType: TypeDeclaration.$type
+				},
+				type: { name: AttributeParamType.type }
+			},
+			superTypes: []
+		},
+		BinaryExpr: {
+			name: BinaryExpr.$type,
+			properties: {
+				binding: { name: BinaryExpr.binding },
+				left: { name: BinaryExpr.left },
+				operator: { name: BinaryExpr.operator },
+				right: { name: BinaryExpr.right }
+			},
+			superTypes: [Expression.$type]
+		},
+		BooleanLiteral: {
+			name: BooleanLiteral.$type,
+			properties: { value: { name: BooleanLiteral.value } },
+			superTypes: [LiteralExpr.$type]
+		},
+		CollectionPredicateBinding: {
+			name: CollectionPredicateBinding.$type,
+			properties: { name: { name: CollectionPredicateBinding.name } },
+			superTypes: [ReferenceTarget.$type]
+		},
+		ConfigArrayExpr: {
+			name: ConfigArrayExpr.$type,
+			properties: { items: {
+				name: ConfigArrayExpr.items,
+				defaultValue: []
+			} },
+			superTypes: [ConfigExpr.$type]
+		},
+		ConfigExpr: {
+			name: ConfigExpr.$type,
+			properties: {},
+			superTypes: []
+		},
+		ConfigField: {
+			name: ConfigField.$type,
+			properties: {
+				name: { name: ConfigField.name },
+				value: { name: ConfigField.value }
+			},
+			superTypes: []
+		},
+		ConfigInvocationArg: {
+			name: ConfigInvocationArg.$type,
+			properties: {
+				name: { name: ConfigInvocationArg.name },
+				value: { name: ConfigInvocationArg.value }
+			},
+			superTypes: []
+		},
+		ConfigInvocationExpr: {
+			name: ConfigInvocationExpr.$type,
+			properties: {
+				args: {
+					name: ConfigInvocationExpr.args,
+					defaultValue: []
+				},
+				name: { name: ConfigInvocationExpr.name }
+			},
+			superTypes: []
+		},
+		DataField: {
+			name: DataField.$type,
+			properties: {
+				attributes: {
+					name: DataField.attributes,
+					defaultValue: []
+				},
+				comments: {
+					name: DataField.comments,
+					defaultValue: []
+				},
+				name: { name: DataField.name },
+				type: { name: DataField.type }
+			},
+			superTypes: [MemberAccessTarget.$type, ReferenceTarget.$type]
+		},
+		DataFieldAttribute: {
+			name: DataFieldAttribute.$type,
+			properties: {
+				args: {
+					name: DataFieldAttribute.args,
+					defaultValue: []
+				},
+				decl: {
+					name: DataFieldAttribute.decl,
+					referenceType: Attribute.$type
+				}
+			},
+			superTypes: []
+		},
+		DataFieldType: {
+			name: DataFieldType.$type,
+			properties: {
+				array: {
+					name: DataFieldType.array,
+					defaultValue: false
+				},
+				optional: {
+					name: DataFieldType.optional,
+					defaultValue: false
+				},
+				reference: {
+					name: DataFieldType.reference,
+					referenceType: TypeDeclaration.$type
+				},
+				type: { name: DataFieldType.type },
+				unsupported: { name: DataFieldType.unsupported }
+			},
+			superTypes: []
+		},
+		DataModel: {
+			name: DataModel.$type,
+			properties: {
+				attributes: {
+					name: DataModel.attributes,
+					defaultValue: []
+				},
+				baseModel: {
+					name: DataModel.baseModel,
+					referenceType: DataModel.$type
+				},
+				comments: {
+					name: DataModel.comments,
+					defaultValue: []
+				},
+				fields: {
+					name: DataModel.fields,
+					defaultValue: []
+				},
+				isView: {
+					name: DataModel.isView,
+					defaultValue: false
+				},
+				mixins: {
+					name: DataModel.mixins,
+					defaultValue: [],
+					referenceType: TypeDef.$type
+				},
+				name: { name: DataModel.name }
+			},
+			superTypes: [AbstractDeclaration.$type, TypeDeclaration.$type]
+		},
+		DataModelAttribute: {
+			name: DataModelAttribute.$type,
+			properties: {
+				args: {
+					name: DataModelAttribute.args,
+					defaultValue: []
+				},
+				decl: {
+					name: DataModelAttribute.decl,
+					referenceType: Attribute.$type
+				}
+			},
+			superTypes: []
+		},
+		DataSource: {
+			name: DataSource.$type,
+			properties: {
+				fields: {
+					name: DataSource.fields,
+					defaultValue: []
+				},
+				name: { name: DataSource.name }
+			},
+			superTypes: [AbstractDeclaration.$type]
+		},
+		Enum: {
+			name: Enum.$type,
+			properties: {
+				attributes: {
+					name: Enum.attributes,
+					defaultValue: []
+				},
+				comments: {
+					name: Enum.comments,
+					defaultValue: []
+				},
+				fields: {
+					name: Enum.fields,
+					defaultValue: []
+				},
+				name: { name: Enum.name }
+			},
+			superTypes: [AbstractDeclaration.$type, TypeDeclaration.$type]
+		},
+		EnumField: {
+			name: EnumField.$type,
+			properties: {
+				attributes: {
+					name: EnumField.attributes,
+					defaultValue: []
+				},
+				comments: {
+					name: EnumField.comments,
+					defaultValue: []
+				},
+				name: { name: EnumField.name }
+			},
+			superTypes: [ReferenceTarget.$type]
+		},
+		Expression: {
+			name: Expression.$type,
+			properties: {},
+			superTypes: []
+		},
+		FieldInitializer: {
+			name: FieldInitializer.$type,
+			properties: {
+				name: { name: FieldInitializer.name },
+				value: { name: FieldInitializer.value }
+			},
+			superTypes: []
+		},
+		FunctionDecl: {
+			name: FunctionDecl.$type,
+			properties: {
+				attributes: {
+					name: FunctionDecl.attributes,
+					defaultValue: []
+				},
+				expression: { name: FunctionDecl.expression },
+				name: { name: FunctionDecl.name },
+				params: {
+					name: FunctionDecl.params,
+					defaultValue: []
+				},
+				returnType: { name: FunctionDecl.returnType }
+			},
+			superTypes: [AbstractDeclaration.$type]
+		},
+		FunctionParam: {
+			name: FunctionParam.$type,
+			properties: {
+				name: { name: FunctionParam.name },
+				optional: {
+					name: FunctionParam.optional,
+					defaultValue: false
+				},
+				type: { name: FunctionParam.type }
+			},
+			superTypes: [ReferenceTarget.$type]
+		},
+		FunctionParamType: {
+			name: FunctionParamType.$type,
+			properties: {
+				array: {
+					name: FunctionParamType.array,
+					defaultValue: false
+				},
+				reference: {
+					name: FunctionParamType.reference,
+					referenceType: TypeDeclaration.$type
+				},
+				type: { name: FunctionParamType.type }
+			},
+			superTypes: []
+		},
+		GeneratorDecl: {
+			name: GeneratorDecl.$type,
+			properties: {
+				fields: {
+					name: GeneratorDecl.fields,
+					defaultValue: []
+				},
+				name: { name: GeneratorDecl.name }
+			},
+			superTypes: [AbstractDeclaration.$type]
+		},
+		InternalAttribute: {
+			name: InternalAttribute.$type,
+			properties: {
+				args: {
+					name: InternalAttribute.args,
+					defaultValue: []
+				},
+				decl: {
+					name: InternalAttribute.decl,
+					referenceType: Attribute.$type
+				}
+			},
+			superTypes: []
+		},
+		InvocationExpr: {
+			name: InvocationExpr.$type,
+			properties: {
+				args: {
+					name: InvocationExpr.args,
+					defaultValue: []
+				},
+				function: {
+					name: InvocationExpr.function,
+					referenceType: FunctionDecl.$type
+				}
+			},
+			superTypes: [ConfigExpr.$type, Expression.$type]
+		},
+		LiteralExpr: {
+			name: LiteralExpr.$type,
+			properties: {},
+			superTypes: [ConfigExpr.$type, Expression.$type]
+		},
+		MemberAccessExpr: {
+			name: MemberAccessExpr.$type,
+			properties: {
+				member: {
+					name: MemberAccessExpr.member,
+					referenceType: MemberAccessTarget.$type
+				},
+				operand: { name: MemberAccessExpr.operand }
+			},
+			superTypes: [Expression.$type]
+		},
+		MemberAccessTarget: {
+			name: MemberAccessTarget.$type,
+			properties: {},
+			superTypes: []
+		},
+		Model: {
+			name: Model.$type,
+			properties: {
+				declarations: {
+					name: Model.declarations,
+					defaultValue: []
+				},
+				imports: {
+					name: Model.imports,
+					defaultValue: []
+				}
+			},
+			superTypes: []
+		},
+		ModelImport: {
+			name: ModelImport.$type,
+			properties: { path: { name: ModelImport.path } },
+			superTypes: []
+		},
+		NullExpr: {
+			name: NullExpr.$type,
+			properties: { value: { name: NullExpr.value } },
+			superTypes: [Expression.$type]
+		},
+		NumberLiteral: {
+			name: NumberLiteral.$type,
+			properties: { value: { name: NumberLiteral.value } },
+			superTypes: [LiteralExpr.$type]
+		},
+		ObjectExpr: {
+			name: ObjectExpr.$type,
+			properties: { fields: {
+				name: ObjectExpr.fields,
+				defaultValue: []
+			} },
+			superTypes: [Expression.$type]
+		},
+		Plugin: {
+			name: Plugin.$type,
+			properties: {
+				fields: {
+					name: Plugin.fields,
+					defaultValue: []
+				},
+				name: { name: Plugin.name }
+			},
+			superTypes: [AbstractDeclaration.$type]
+		},
+		PluginField: {
+			name: PluginField.$type,
+			properties: {
+				name: { name: PluginField.name },
+				value: { name: PluginField.value }
+			},
+			superTypes: []
+		},
+		Procedure: {
+			name: Procedure.$type,
+			properties: {
+				attributes: {
+					name: Procedure.attributes,
+					defaultValue: []
+				},
+				mutation: {
+					name: Procedure.mutation,
+					defaultValue: false
+				},
+				name: { name: Procedure.name },
+				params: {
+					name: Procedure.params,
+					defaultValue: []
+				},
+				returnType: { name: Procedure.returnType }
+			},
+			superTypes: [AbstractDeclaration.$type]
+		},
+		ProcedureParam: {
+			name: ProcedureParam.$type,
+			properties: {
+				name: { name: ProcedureParam.name },
+				optional: {
+					name: ProcedureParam.optional,
+					defaultValue: false
+				},
+				type: { name: ProcedureParam.type }
+			},
+			superTypes: []
+		},
+		ReferenceArg: {
+			name: ReferenceArg.$type,
+			properties: {
+				name: { name: ReferenceArg.name },
+				value: { name: ReferenceArg.value }
+			},
+			superTypes: []
+		},
+		ReferenceExpr: {
+			name: ReferenceExpr.$type,
+			properties: {
+				args: {
+					name: ReferenceExpr.args,
+					defaultValue: []
+				},
+				target: {
+					name: ReferenceExpr.target,
+					referenceType: ReferenceTarget.$type
+				}
+			},
+			superTypes: [Expression.$type]
+		},
+		ReferenceTarget: {
+			name: ReferenceTarget.$type,
+			properties: {},
+			superTypes: []
+		},
+		StringLiteral: {
+			name: StringLiteral.$type,
+			properties: { value: { name: StringLiteral.value } },
+			superTypes: [LiteralExpr.$type]
+		},
+		ThisExpr: {
+			name: ThisExpr.$type,
+			properties: { value: { name: ThisExpr.value } },
+			superTypes: [Expression.$type]
+		},
+		TypeDeclaration: {
+			name: TypeDeclaration.$type,
+			properties: {},
+			superTypes: []
+		},
+		TypeDef: {
+			name: TypeDef.$type,
+			properties: {
+				attributes: {
+					name: TypeDef.attributes,
+					defaultValue: []
+				},
+				comments: {
+					name: TypeDef.comments,
+					defaultValue: []
+				},
+				fields: {
+					name: TypeDef.fields,
+					defaultValue: []
+				},
+				mixins: {
+					name: TypeDef.mixins,
+					defaultValue: [],
+					referenceType: TypeDef.$type
+				},
+				name: { name: TypeDef.name }
+			},
+			superTypes: [AbstractDeclaration.$type, TypeDeclaration.$type]
+		},
+		UnaryExpr: {
+			name: UnaryExpr.$type,
+			properties: {
+				operand: { name: UnaryExpr.operand },
+				operator: { name: UnaryExpr.operator }
+			},
+			superTypes: [Expression.$type]
+		},
+		UnsupportedFieldType: {
+			name: UnsupportedFieldType.$type,
+			properties: { value: { name: UnsupportedFieldType.value } },
+			superTypes: []
+		}
+	};
+};
+const reflection = new ZModelAstReflection();
+//#endregion
+Object.defineProperty(exports, "AbstractDeclaration", {
+	enumerable: true,
+	get: function() {
+		return AbstractDeclaration;
+	}
+});
+Object.defineProperty(exports, "Argument", {
+	enumerable: true,
+	get: function() {
+		return Argument;
+	}
+});
+Object.defineProperty(exports, "ArrayExpr", {
+	enumerable: true,
+	get: function() {
+		return ArrayExpr;
+	}
+});
+Object.defineProperty(exports, "Attribute", {
+	enumerable: true,
+	get: function() {
+		return Attribute;
+	}
+});
+Object.defineProperty(exports, "AttributeArg", {
+	enumerable: true,
+	get: function() {
+		return AttributeArg;
+	}
+});
+Object.defineProperty(exports, "AttributeParam", {
+	enumerable: true,
+	get: function() {
+		return AttributeParam;
+	}
+});
+Object.defineProperty(exports, "AttributeParamType", {
+	enumerable: true,
+	get: function() {
+		return AttributeParamType;
+	}
+});
+Object.defineProperty(exports, "BinaryExpr", {
+	enumerable: true,
+	get: function() {
+		return BinaryExpr;
+	}
+});
+Object.defineProperty(exports, "BooleanLiteral", {
+	enumerable: true,
+	get: function() {
+		return BooleanLiteral;
+	}
+});
+Object.defineProperty(exports, "CollectionPredicateBinding", {
+	enumerable: true,
+	get: function() {
+		return CollectionPredicateBinding;
+	}
+});
+Object.defineProperty(exports, "ConfigArrayExpr", {
+	enumerable: true,
+	get: function() {
+		return ConfigArrayExpr;
+	}
+});
+Object.defineProperty(exports, "ConfigExpr", {
+	enumerable: true,
+	get: function() {
+		return ConfigExpr;
+	}
+});
+Object.defineProperty(exports, "ConfigField", {
+	enumerable: true,
+	get: function() {
+		return ConfigField;
+	}
+});
+Object.defineProperty(exports, "ConfigInvocationArg", {
+	enumerable: true,
+	get: function() {
+		return ConfigInvocationArg;
+	}
+});
+Object.defineProperty(exports, "ConfigInvocationExpr", {
+	enumerable: true,
+	get: function() {
+		return ConfigInvocationExpr;
+	}
+});
+Object.defineProperty(exports, "DataField", {
+	enumerable: true,
+	get: function() {
+		return DataField;
+	}
+});
+Object.defineProperty(exports, "DataFieldAttribute", {
+	enumerable: true,
+	get: function() {
+		return DataFieldAttribute;
+	}
+});
+Object.defineProperty(exports, "DataFieldType", {
+	enumerable: true,
+	get: function() {
+		return DataFieldType;
+	}
+});
+Object.defineProperty(exports, "DataModel", {
+	enumerable: true,
+	get: function() {
+		return DataModel;
+	}
+});
+Object.defineProperty(exports, "DataModelAttribute", {
+	enumerable: true,
+	get: function() {
+		return DataModelAttribute;
+	}
+});
+Object.defineProperty(exports, "DataSource", {
+	enumerable: true,
+	get: function() {
+		return DataSource;
+	}
+});
+Object.defineProperty(exports, "Enum", {
+	enumerable: true,
+	get: function() {
+		return Enum;
+	}
+});
+Object.defineProperty(exports, "EnumField", {
+	enumerable: true,
+	get: function() {
+		return EnumField;
+	}
+});
+Object.defineProperty(exports, "Expression", {
+	enumerable: true,
+	get: function() {
+		return Expression;
+	}
+});
+Object.defineProperty(exports, "FieldInitializer", {
+	enumerable: true,
+	get: function() {
+		return FieldInitializer;
+	}
+});
+Object.defineProperty(exports, "FunctionDecl", {
+	enumerable: true,
+	get: function() {
+		return FunctionDecl;
+	}
+});
+Object.defineProperty(exports, "FunctionParam", {
+	enumerable: true,
+	get: function() {
+		return FunctionParam;
+	}
+});
+Object.defineProperty(exports, "FunctionParamType", {
+	enumerable: true,
+	get: function() {
+		return FunctionParamType;
+	}
+});
+Object.defineProperty(exports, "GeneratorDecl", {
+	enumerable: true,
+	get: function() {
+		return GeneratorDecl;
+	}
+});
+Object.defineProperty(exports, "InternalAttribute", {
+	enumerable: true,
+	get: function() {
+		return InternalAttribute;
+	}
+});
+Object.defineProperty(exports, "InvocationExpr", {
+	enumerable: true,
+	get: function() {
+		return InvocationExpr;
+	}
+});
+Object.defineProperty(exports, "LiteralExpr", {
+	enumerable: true,
+	get: function() {
+		return LiteralExpr;
+	}
+});
+Object.defineProperty(exports, "MemberAccessExpr", {
+	enumerable: true,
+	get: function() {
+		return MemberAccessExpr;
+	}
+});
+Object.defineProperty(exports, "MemberAccessTarget", {
+	enumerable: true,
+	get: function() {
+		return MemberAccessTarget;
+	}
+});
+Object.defineProperty(exports, "Model", {
+	enumerable: true,
+	get: function() {
+		return Model;
+	}
+});
+Object.defineProperty(exports, "ModelImport", {
+	enumerable: true,
+	get: function() {
+		return ModelImport;
+	}
+});
+Object.defineProperty(exports, "NullExpr", {
+	enumerable: true,
+	get: function() {
+		return NullExpr;
+	}
+});
+Object.defineProperty(exports, "NumberLiteral", {
+	enumerable: true,
+	get: function() {
+		return NumberLiteral;
+	}
+});
+Object.defineProperty(exports, "ObjectExpr", {
+	enumerable: true,
+	get: function() {
+		return ObjectExpr;
+	}
+});
+Object.defineProperty(exports, "Plugin", {
+	enumerable: true,
+	get: function() {
+		return Plugin;
+	}
+});
+Object.defineProperty(exports, "PluginField", {
+	enumerable: true,
+	get: function() {
+		return PluginField;
+	}
+});
+Object.defineProperty(exports, "Procedure", {
+	enumerable: true,
+	get: function() {
+		return Procedure;
+	}
+});
+Object.defineProperty(exports, "ProcedureParam", {
+	enumerable: true,
+	get: function() {
+		return ProcedureParam;
+	}
+});
+Object.defineProperty(exports, "ReferenceArg", {
+	enumerable: true,
+	get: function() {
+		return ReferenceArg;
+	}
+});
+Object.defineProperty(exports, "ReferenceExpr", {
+	enumerable: true,
+	get: function() {
+		return ReferenceExpr;
+	}
+});
+Object.defineProperty(exports, "ReferenceTarget", {
+	enumerable: true,
+	get: function() {
+		return ReferenceTarget;
+	}
+});
+Object.defineProperty(exports, "StringLiteral", {
+	enumerable: true,
+	get: function() {
+		return StringLiteral;
+	}
+});
+Object.defineProperty(exports, "ThisExpr", {
+	enumerable: true,
+	get: function() {
+		return ThisExpr;
+	}
+});
+Object.defineProperty(exports, "TypeDeclaration", {
+	enumerable: true,
+	get: function() {
+		return TypeDeclaration;
+	}
+});
+Object.defineProperty(exports, "TypeDef", {
+	enumerable: true,
+	get: function() {
+		return TypeDef;
+	}
+});
+Object.defineProperty(exports, "UnaryExpr", {
+	enumerable: true,
+	get: function() {
+		return UnaryExpr;
+	}
+});
+Object.defineProperty(exports, "UnsupportedFieldType", {
+	enumerable: true,
+	get: function() {
+		return UnsupportedFieldType;
+	}
+});
+Object.defineProperty(exports, "ZModelAstReflection", {
+	enumerable: true,
+	get: function() {
+		return ZModelAstReflection;
+	}
+});
+Object.defineProperty(exports, "ZModelTerminals", {
+	enumerable: true,
+	get: function() {
+		return ZModelTerminals;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "isAbstractDeclaration", {
+	enumerable: true,
+	get: function() {
+		return isAbstractDeclaration;
+	}
+});
+Object.defineProperty(exports, "isArgument", {
+	enumerable: true,
+	get: function() {
+		return isArgument;
+	}
+});
+Object.defineProperty(exports, "isArrayExpr", {
+	enumerable: true,
+	get: function() {
+		return isArrayExpr;
+	}
+});
+Object.defineProperty(exports, "isAttribute", {
+	enumerable: true,
+	get: function() {
+		return isAttribute;
+	}
+});
+Object.defineProperty(exports, "isAttributeArg", {
+	enumerable: true,
+	get: function() {
+		return isAttributeArg;
+	}
+});
+Object.defineProperty(exports, "isAttributeParam", {
+	enumerable: true,
+	get: function() {
+		return isAttributeParam;
+	}
+});
+Object.defineProperty(exports, "isAttributeParamType", {
+	enumerable: true,
+	get: function() {
+		return isAttributeParamType;
+	}
+});
+Object.defineProperty(exports, "isBinaryExpr", {
+	enumerable: true,
+	get: function() {
+		return isBinaryExpr;
+	}
+});
+Object.defineProperty(exports, "isBoolean", {
+	enumerable: true,
+	get: function() {
+		return isBoolean;
+	}
+});
+Object.defineProperty(exports, "isBooleanLiteral", {
+	enumerable: true,
+	get: function() {
+		return isBooleanLiteral;
+	}
+});
+Object.defineProperty(exports, "isBuiltinType", {
+	enumerable: true,
+	get: function() {
+		return isBuiltinType;
+	}
+});
+Object.defineProperty(exports, "isCollectionPredicateBinding", {
+	enumerable: true,
+	get: function() {
+		return isCollectionPredicateBinding;
+	}
+});
+Object.defineProperty(exports, "isConfigArrayExpr", {
+	enumerable: true,
+	get: function() {
+		return isConfigArrayExpr;
+	}
+});
+Object.defineProperty(exports, "isConfigExpr", {
+	enumerable: true,
+	get: function() {
+		return isConfigExpr;
+	}
+});
+Object.defineProperty(exports, "isConfigField", {
+	enumerable: true,
+	get: function() {
+		return isConfigField;
+	}
+});
+Object.defineProperty(exports, "isConfigInvocationArg", {
+	enumerable: true,
+	get: function() {
+		return isConfigInvocationArg;
+	}
+});
+Object.defineProperty(exports, "isConfigInvocationExpr", {
+	enumerable: true,
+	get: function() {
+		return isConfigInvocationExpr;
+	}
+});
+Object.defineProperty(exports, "isDataField", {
+	enumerable: true,
+	get: function() {
+		return isDataField;
+	}
+});
+Object.defineProperty(exports, "isDataFieldAttribute", {
+	enumerable: true,
+	get: function() {
+		return isDataFieldAttribute;
+	}
+});
+Object.defineProperty(exports, "isDataFieldType", {
+	enumerable: true,
+	get: function() {
+		return isDataFieldType;
+	}
+});
+Object.defineProperty(exports, "isDataModel", {
+	enumerable: true,
+	get: function() {
+		return isDataModel;
+	}
+});
+Object.defineProperty(exports, "isDataModelAttribute", {
+	enumerable: true,
+	get: function() {
+		return isDataModelAttribute;
+	}
+});
+Object.defineProperty(exports, "isDataSource", {
+	enumerable: true,
+	get: function() {
+		return isDataSource;
+	}
+});
+Object.defineProperty(exports, "isEnum", {
+	enumerable: true,
+	get: function() {
+		return isEnum;
+	}
+});
+Object.defineProperty(exports, "isEnumField", {
+	enumerable: true,
+	get: function() {
+		return isEnumField;
+	}
+});
+Object.defineProperty(exports, "isExpression", {
+	enumerable: true,
+	get: function() {
+		return isExpression;
+	}
+});
+Object.defineProperty(exports, "isExpressionType", {
+	enumerable: true,
+	get: function() {
+		return isExpressionType;
+	}
+});
+Object.defineProperty(exports, "isFieldInitializer", {
+	enumerable: true,
+	get: function() {
+		return isFieldInitializer;
+	}
+});
+Object.defineProperty(exports, "isFunctionDecl", {
+	enumerable: true,
+	get: function() {
+		return isFunctionDecl;
+	}
+});
+Object.defineProperty(exports, "isFunctionParam", {
+	enumerable: true,
+	get: function() {
+		return isFunctionParam;
+	}
+});
+Object.defineProperty(exports, "isFunctionParamType", {
+	enumerable: true,
+	get: function() {
+		return isFunctionParamType;
+	}
+});
+Object.defineProperty(exports, "isGeneratorDecl", {
+	enumerable: true,
+	get: function() {
+		return isGeneratorDecl;
+	}
+});
+Object.defineProperty(exports, "isInternalAttribute", {
+	enumerable: true,
+	get: function() {
+		return isInternalAttribute;
+	}
+});
+Object.defineProperty(exports, "isInvocationExpr", {
+	enumerable: true,
+	get: function() {
+		return isInvocationExpr;
+	}
+});
+Object.defineProperty(exports, "isLiteralExpr", {
+	enumerable: true,
+	get: function() {
+		return isLiteralExpr;
+	}
+});
+Object.defineProperty(exports, "isMemberAccessExpr", {
+	enumerable: true,
+	get: function() {
+		return isMemberAccessExpr;
+	}
+});
+Object.defineProperty(exports, "isMemberAccessTarget", {
+	enumerable: true,
+	get: function() {
+		return isMemberAccessTarget;
+	}
+});
+Object.defineProperty(exports, "isModel", {
+	enumerable: true,
+	get: function() {
+		return isModel;
+	}
+});
+Object.defineProperty(exports, "isModelImport", {
+	enumerable: true,
+	get: function() {
+		return isModelImport;
+	}
+});
+Object.defineProperty(exports, "isNullExpr", {
+	enumerable: true,
+	get: function() {
+		return isNullExpr;
+	}
+});
+Object.defineProperty(exports, "isNumberLiteral", {
+	enumerable: true,
+	get: function() {
+		return isNumberLiteral;
+	}
+});
+Object.defineProperty(exports, "isObjectExpr", {
+	enumerable: true,
+	get: function() {
+		return isObjectExpr;
+	}
+});
+Object.defineProperty(exports, "isPlugin", {
+	enumerable: true,
+	get: function() {
+		return isPlugin;
+	}
+});
+Object.defineProperty(exports, "isPluginField", {
+	enumerable: true,
+	get: function() {
+		return isPluginField;
+	}
+});
+Object.defineProperty(exports, "isProcedure", {
+	enumerable: true,
+	get: function() {
+		return isProcedure;
+	}
+});
+Object.defineProperty(exports, "isProcedureParam", {
+	enumerable: true,
+	get: function() {
+		return isProcedureParam;
+	}
+});
+Object.defineProperty(exports, "isReferenceArg", {
+	enumerable: true,
+	get: function() {
+		return isReferenceArg;
+	}
+});
+Object.defineProperty(exports, "isReferenceExpr", {
+	enumerable: true,
+	get: function() {
+		return isReferenceExpr;
+	}
+});
+Object.defineProperty(exports, "isReferenceTarget", {
+	enumerable: true,
+	get: function() {
+		return isReferenceTarget;
+	}
+});
+Object.defineProperty(exports, "isRegularID", {
+	enumerable: true,
+	get: function() {
+		return isRegularID;
+	}
+});
+Object.defineProperty(exports, "isRegularIDWithTypeNames", {
+	enumerable: true,
+	get: function() {
+		return isRegularIDWithTypeNames;
+	}
+});
+Object.defineProperty(exports, "isStringLiteral", {
+	enumerable: true,
+	get: function() {
+		return isStringLiteral;
+	}
+});
+Object.defineProperty(exports, "isThisExpr", {
+	enumerable: true,
+	get: function() {
+		return isThisExpr;
+	}
+});
+Object.defineProperty(exports, "isTypeDeclaration", {
+	enumerable: true,
+	get: function() {
+		return isTypeDeclaration;
+	}
+});
+Object.defineProperty(exports, "isTypeDef", {
+	enumerable: true,
+	get: function() {
+		return isTypeDef;
+	}
+});
+Object.defineProperty(exports, "isUnaryExpr", {
+	enumerable: true,
+	get: function() {
+		return isUnaryExpr;
+	}
+});
+Object.defineProperty(exports, "isUnsupportedFieldType", {
+	enumerable: true,
+	get: function() {
+		return isUnsupportedFieldType;
+	}
+});
+Object.defineProperty(exports, "reflection", {
+	enumerable: true,
+	get: function() {
+		return reflection;
+	}
+});
+
+//# sourceMappingURL=ast-DHvua30v.cjs.map