/******************************************************************************
 * This file was generated by langium-cli 4.2.1.
 * DO NOT EDIT MANUALLY!
 ******************************************************************************/

/* eslint-disable */
import * as langium from 'langium';

export 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]*/,
};

export type ZModelTerminalNames = keyof typeof ZModelTerminals;

export type ZModelKeywordNames =
    | "!"
    | "!="
    | "&&"
    | "("
    | ")"
    | ","
    | "."
    | ":"
    | ";"
    | "<"
    | "<="
    | "="
    | "=="
    | ">"
    | ">="
    | "?"
    | "Any"
    | "BigInt"
    | "Boolean"
    | "Bytes"
    | "ContextType"
    | "DateTime"
    | "Decimal"
    | "FieldReference"
    | "Float"
    | "Int"
    | "Json"
    | "Null"
    | "Object"
    | "String"
    | "TransitiveFieldReference"
    | "Undefined"
    | "Unsupported"
    | "Void"
    | "["
    | "]"
    | "^"
    | "_"
    | "abstract"
    | "attribute"
    | "datasource"
    | "enum"
    | "extends"
    | "false"
    | "function"
    | "generator"
    | "import"
    | "in"
    | "model"
    | "mutation"
    | "null"
    | "plugin"
    | "procedure"
    | "this"
    | "true"
    | "type"
    | "view"
    | "with"
    | "{"
    | "||"
    | "}";

export type ZModelTokenNames = ZModelTerminalNames | ZModelKeywordNames;

export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | FunctionDecl | GeneratorDecl | Plugin | Procedure | TypeDef;

export const AbstractDeclaration = {
    $type: 'AbstractDeclaration'
} as const;

export function isAbstractDeclaration(item: unknown): item is AbstractDeclaration {
    return reflection.isInstance(item, AbstractDeclaration.$type);
}

export interface Argument extends langium.AstNode {
    readonly $container: InvocationExpr;
    readonly $type: 'Argument';
    value: Expression;
}

export const Argument = {
    $type: 'Argument',
    value: 'value'
} as const;

export function isArgument(item: unknown): item is Argument {
    return reflection.isInstance(item, Argument.$type);
}

export interface ArrayExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr;
    readonly $type: 'ArrayExpr';
    items: Array<Expression>;
}

export const ArrayExpr = {
    $type: 'ArrayExpr',
    items: 'items'
} as const;

export function isArrayExpr(item: unknown): item is ArrayExpr {
    return reflection.isInstance(item, ArrayExpr.$type);
}

export interface Attribute extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'Attribute';
    attributes: Array<InternalAttribute>;
    comments: Array<string>;
    name: string;
    params: Array<AttributeParam>;
}

export const Attribute = {
    $type: 'Attribute',
    attributes: 'attributes',
    comments: 'comments',
    name: 'name',
    params: 'params'
} as const;

export function isAttribute(item: unknown): item is Attribute {
    return reflection.isInstance(item, Attribute.$type);
}

export interface AttributeArg extends langium.AstNode {
    readonly $container: DataFieldAttribute | DataModelAttribute | InternalAttribute;
    readonly $type: 'AttributeArg';
    name?: RegularID;
    value: Expression;
    /** Resolved attribute param declaration */
    $resolvedParam?: AttributeParam;
}

export const AttributeArg = {
    $type: 'AttributeArg',
    name: 'name',
    value: 'value'
} as const;

export function isAttributeArg(item: unknown): item is AttributeArg {
    return reflection.isInstance(item, AttributeArg.$type);
}

export interface AttributeParam extends langium.AstNode {
    readonly $container: Attribute;
    readonly $type: 'AttributeParam';
    attributes: Array<InternalAttribute>;
    comments: Array<string>;
    default: boolean;
    name: RegularID;
    type: AttributeParamType;
}

export const AttributeParam = {
    $type: 'AttributeParam',
    attributes: 'attributes',
    comments: 'comments',
    default: 'default',
    name: 'name',
    type: 'type'
} as const;

export function isAttributeParam(item: unknown): item is AttributeParam {
    return reflection.isInstance(item, AttributeParam.$type);
}

export interface AttributeParamType extends langium.AstNode {
    readonly $container: AttributeParam;
    readonly $type: 'AttributeParamType';
    array: boolean;
    optional: boolean;
    reference?: langium.Reference<TypeDeclaration>;
    type?: 'ContextType' | 'FieldReference' | 'TransitiveFieldReference' | ExpressionType;
}

export const AttributeParamType = {
    $type: 'AttributeParamType',
    array: 'array',
    optional: 'optional',
    reference: 'reference',
    type: 'type'
} as const;

export function isAttributeParamType(item: unknown): item is AttributeParamType {
    return reflection.isInstance(item, AttributeParamType.$type);
}

export interface BinaryExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'BinaryExpr';
    binding?: CollectionPredicateBinding;
    left: Expression;
    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | 'in' | '||';
    right: Expression;
}

export const BinaryExpr = {
    $type: 'BinaryExpr',
    binding: 'binding',
    left: 'left',
    operator: 'operator',
    right: 'right'
} as const;

export function isBinaryExpr(item: unknown): item is BinaryExpr {
    return reflection.isInstance(item, BinaryExpr.$type);
}

export type Boolean = boolean;

export function isBoolean(item: unknown): item is Boolean {
    return typeof item === 'boolean';
}

export interface BooleanLiteral extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigArrayExpr | ConfigField | ConfigInvocationArg | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr | UnsupportedFieldType;
    readonly $type: 'BooleanLiteral';
    value: Boolean;
}

export const BooleanLiteral = {
    $type: 'BooleanLiteral',
    value: 'value'
} as const;

export function isBooleanLiteral(item: unknown): item is BooleanLiteral {
    return reflection.isInstance(item, BooleanLiteral.$type);
}

export type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String';

export function isBuiltinType(item: unknown): item is BuiltinType {
    return item === 'String' || item === 'Boolean' || item === 'Int' || item === 'BigInt' || item === 'Float' || item === 'Decimal' || item === 'DateTime' || item === 'Json' || item === 'Bytes';
}

export interface CollectionPredicateBinding extends langium.AstNode {
    readonly $container: BinaryExpr;
    readonly $type: 'CollectionPredicateBinding';
    name: RegularID;
}

export const CollectionPredicateBinding = {
    $type: 'CollectionPredicateBinding',
    name: 'name'
} as const;

export function isCollectionPredicateBinding(item: unknown): item is CollectionPredicateBinding {
    return reflection.isInstance(item, CollectionPredicateBinding.$type);
}

export interface ConfigArrayExpr extends langium.AstNode {
    readonly $container: ConfigField;
    readonly $type: 'ConfigArrayExpr';
    items: Array<ConfigInvocationExpr | LiteralExpr>;
}

export const ConfigArrayExpr = {
    $type: 'ConfigArrayExpr',
    items: 'items'
} as const;

export function isConfigArrayExpr(item: unknown): item is ConfigArrayExpr {
    return reflection.isInstance(item, ConfigArrayExpr.$type);
}

export type ConfigExpr = ConfigArrayExpr | InvocationExpr | LiteralExpr;

export const ConfigExpr = {
    $type: 'ConfigExpr'
} as const;

export function isConfigExpr(item: unknown): item is ConfigExpr {
    return reflection.isInstance(item, ConfigExpr.$type);
}

export interface ConfigField extends langium.AstNode {
    readonly $container: DataSource | GeneratorDecl;
    readonly $type: 'ConfigField';
    name: RegularID;
    value: ConfigExpr;
}

export const ConfigField = {
    $type: 'ConfigField',
    name: 'name',
    value: 'value'
} as const;

export function isConfigField(item: unknown): item is ConfigField {
    return reflection.isInstance(item, ConfigField.$type);
}

export interface ConfigInvocationArg extends langium.AstNode {
    readonly $container: ConfigInvocationExpr;
    readonly $type: 'ConfigInvocationArg';
    name: string;
    value: LiteralExpr;
}

export const ConfigInvocationArg = {
    $type: 'ConfigInvocationArg',
    name: 'name',
    value: 'value'
} as const;

export function isConfigInvocationArg(item: unknown): item is ConfigInvocationArg {
    return reflection.isInstance(item, ConfigInvocationArg.$type);
}

export interface ConfigInvocationExpr extends langium.AstNode {
    readonly $container: ConfigArrayExpr;
    readonly $type: 'ConfigInvocationExpr';
    args: Array<ConfigInvocationArg>;
    name: string;
}

export const ConfigInvocationExpr = {
    $type: 'ConfigInvocationExpr',
    args: 'args',
    name: 'name'
} as const;

export function isConfigInvocationExpr(item: unknown): item is ConfigInvocationExpr {
    return reflection.isInstance(item, ConfigInvocationExpr.$type);
}

export interface DataField extends langium.AstNode {
    readonly $container: DataModel | TypeDef;
    readonly $type: 'DataField';
    attributes: Array<DataFieldAttribute>;
    comments: Array<string>;
    name: RegularIDWithTypeNames;
    params: Array<DataFieldParam>;
    type: DataFieldType;
}

export const DataField = {
    $type: 'DataField',
    attributes: 'attributes',
    comments: 'comments',
    name: 'name',
    params: 'params',
    type: 'type'
} as const;

export function isDataField(item: unknown): item is DataField {
    return reflection.isInstance(item, DataField.$type);
}

export interface DataFieldAttribute extends langium.AstNode {
    readonly $container: DataField | EnumField;
    readonly $type: 'DataFieldAttribute';
    args: Array<AttributeArg>;
    decl: langium.Reference<Attribute>;
}

export const DataFieldAttribute = {
    $type: 'DataFieldAttribute',
    args: 'args',
    decl: 'decl'
} as const;

export function isDataFieldAttribute(item: unknown): item is DataFieldAttribute {
    return reflection.isInstance(item, DataFieldAttribute.$type);
}

export interface DataFieldParam extends langium.AstNode {
    readonly $container: DataField;
    readonly $type: 'DataFieldParam';
    name: RegularID;
    optional: boolean;
    type: FunctionParamType;
}

export const DataFieldParam = {
    $type: 'DataFieldParam',
    name: 'name',
    optional: 'optional',
    type: 'type'
} as const;

export function isDataFieldParam(item: unknown): item is DataFieldParam {
    return reflection.isInstance(item, DataFieldParam.$type);
}

export interface DataFieldType extends langium.AstNode {
    readonly $container: DataField;
    readonly $type: 'DataFieldType';
    array: boolean;
    optional: boolean;
    reference?: langium.Reference<TypeDeclaration>;
    type?: BuiltinType;
    unsupported?: UnsupportedFieldType;
}

export const DataFieldType = {
    $type: 'DataFieldType',
    array: 'array',
    optional: 'optional',
    reference: 'reference',
    type: 'type',
    unsupported: 'unsupported'
} as const;

export function isDataFieldType(item: unknown): item is DataFieldType {
    return reflection.isInstance(item, DataFieldType.$type);
}

export interface DataModel extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'DataModel';
    attributes: Array<DataModelAttribute>;
    baseModel?: langium.Reference<DataModel>;
    comments: Array<string>;
    fields: Array<DataField>;
    isView: boolean;
    mixins: Array<langium.Reference<TypeDef>>;
    name: RegularID;
    /** All fields including those marked with `@ignore` */
    $allFields?: DataField[];
}

export const DataModel = {
    $type: 'DataModel',
    attributes: 'attributes',
    baseModel: 'baseModel',
    comments: 'comments',
    fields: 'fields',
    isView: 'isView',
    mixins: 'mixins',
    name: 'name'
} as const;

export function isDataModel(item: unknown): item is DataModel {
    return reflection.isInstance(item, DataModel.$type);
}

export interface DataModelAttribute extends langium.AstNode {
    readonly $container: DataModel | Enum | TypeDef;
    readonly $type: 'DataModelAttribute';
    args: Array<AttributeArg>;
    decl: langium.Reference<Attribute>;
}

export const DataModelAttribute = {
    $type: 'DataModelAttribute',
    args: 'args',
    decl: 'decl'
} as const;

export function isDataModelAttribute(item: unknown): item is DataModelAttribute {
    return reflection.isInstance(item, DataModelAttribute.$type);
}

export interface DataSource extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'DataSource';
    fields: Array<ConfigField>;
    name: RegularID;
}

export const DataSource = {
    $type: 'DataSource',
    fields: 'fields',
    name: 'name'
} as const;

export function isDataSource(item: unknown): item is DataSource {
    return reflection.isInstance(item, DataSource.$type);
}

export interface Enum extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'Enum';
    attributes: Array<DataModelAttribute>;
    comments: Array<string>;
    fields: Array<EnumField>;
    name: RegularID;
}

export const Enum = {
    $type: 'Enum',
    attributes: 'attributes',
    comments: 'comments',
    fields: 'fields',
    name: 'name'
} as const;

export function isEnum(item: unknown): item is Enum {
    return reflection.isInstance(item, Enum.$type);
}

export interface EnumField extends langium.AstNode {
    readonly $container: Enum;
    readonly $type: 'EnumField';
    attributes: Array<DataFieldAttribute>;
    comments: Array<string>;
    name: RegularIDWithTypeNames;
}

export const EnumField = {
    $type: 'EnumField',
    attributes: 'attributes',
    comments: 'comments',
    name: 'name'
} as const;

export function isEnumField(item: unknown): item is EnumField {
    return reflection.isInstance(item, EnumField.$type);
}

export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ObjectExpr | ReferenceExpr | ThisExpr | UnaryExpr;

export const Expression = {
    $type: 'Expression'
} as const;

export function isExpression(item: unknown): item is Expression {
    return reflection.isInstance(item, Expression.$type);
}

export type ExpressionType = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Undefined' | 'Unsupported' | 'Void';

export function isExpressionType(item: unknown): item is ExpressionType {
    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';
}

export interface FieldInitializer extends langium.AstNode {
    readonly $container: ObjectExpr;
    readonly $type: 'FieldInitializer';
    name: RegularID | string;
    value: Expression;
}

export const FieldInitializer = {
    $type: 'FieldInitializer',
    name: 'name',
    value: 'value'
} as const;

export function isFieldInitializer(item: unknown): item is FieldInitializer {
    return reflection.isInstance(item, FieldInitializer.$type);
}

export interface FunctionDecl extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'FunctionDecl';
    attributes: Array<InternalAttribute>;
    expression?: Expression;
    name: RegularID;
    params: Array<FunctionParam>;
    returnType: FunctionParamType;
}

export const FunctionDecl = {
    $type: 'FunctionDecl',
    attributes: 'attributes',
    expression: 'expression',
    name: 'name',
    params: 'params',
    returnType: 'returnType'
} as const;

export function isFunctionDecl(item: unknown): item is FunctionDecl {
    return reflection.isInstance(item, FunctionDecl.$type);
}

export interface FunctionParam extends langium.AstNode {
    readonly $container: FunctionDecl;
    readonly $type: 'FunctionParam';
    name: RegularID;
    optional: boolean;
    type: FunctionParamType;
}

export const FunctionParam = {
    $type: 'FunctionParam',
    name: 'name',
    optional: 'optional',
    type: 'type'
} as const;

export function isFunctionParam(item: unknown): item is FunctionParam {
    return reflection.isInstance(item, FunctionParam.$type);
}

export interface FunctionParamType extends langium.AstNode {
    readonly $container: DataFieldParam | FunctionDecl | FunctionParam | Procedure | ProcedureParam;
    readonly $type: 'FunctionParamType';
    array: boolean;
    reference?: langium.Reference<TypeDeclaration>;
    type?: ExpressionType;
}

export const FunctionParamType = {
    $type: 'FunctionParamType',
    array: 'array',
    reference: 'reference',
    type: 'type'
} as const;

export function isFunctionParamType(item: unknown): item is FunctionParamType {
    return reflection.isInstance(item, FunctionParamType.$type);
}

export interface GeneratorDecl extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'GeneratorDecl';
    fields: Array<ConfigField>;
    name: RegularID;
}

export const GeneratorDecl = {
    $type: 'GeneratorDecl',
    fields: 'fields',
    name: 'name'
} as const;

export function isGeneratorDecl(item: unknown): item is GeneratorDecl {
    return reflection.isInstance(item, GeneratorDecl.$type);
}

export interface InternalAttribute extends langium.AstNode {
    readonly $container: Attribute | AttributeParam | FunctionDecl | Procedure;
    readonly $type: 'InternalAttribute';
    args: Array<AttributeArg>;
    decl: langium.Reference<Attribute>;
}

export const InternalAttribute = {
    $type: 'InternalAttribute',
    args: 'args',
    decl: 'decl'
} as const;

export function isInternalAttribute(item: unknown): item is InternalAttribute {
    return reflection.isInstance(item, InternalAttribute.$type);
}

export interface InvocationExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigField | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'InvocationExpr';
    args: Array<Argument>;
    function: langium.Reference<FunctionDecl>;
}

export const InvocationExpr = {
    $type: 'InvocationExpr',
    args: 'args',
    function: 'function'
} as const;

export function isInvocationExpr(item: unknown): item is InvocationExpr {
    return reflection.isInstance(item, InvocationExpr.$type);
}

export type LiteralExpr = BooleanLiteral | NumberLiteral | StringLiteral;

export const LiteralExpr = {
    $type: 'LiteralExpr'
} as const;

export function isLiteralExpr(item: unknown): item is LiteralExpr {
    return reflection.isInstance(item, LiteralExpr.$type);
}

export interface MemberAccessExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'MemberAccessExpr';
    member: langium.Reference<MemberAccessTarget>;
    operand: Expression;
}

export const MemberAccessExpr = {
    $type: 'MemberAccessExpr',
    member: 'member',
    operand: 'operand'
} as const;

export function isMemberAccessExpr(item: unknown): item is MemberAccessExpr {
    return reflection.isInstance(item, MemberAccessExpr.$type);
}

export type MemberAccessTarget = DataField;

export const MemberAccessTarget = {
    $type: 'MemberAccessTarget'
} as const;

export function isMemberAccessTarget(item: unknown): item is MemberAccessTarget {
    return reflection.isInstance(item, MemberAccessTarget.$type);
}

export interface Model extends langium.AstNode {
    readonly $type: 'Model';
    declarations: Array<AbstractDeclaration>;
    imports: Array<ModelImport>;
}

export const Model = {
    $type: 'Model',
    declarations: 'declarations',
    imports: 'imports'
} as const;

export function isModel(item: unknown): item is Model {
    return reflection.isInstance(item, Model.$type);
}

export interface ModelImport extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'ModelImport';
    path: string;
}

export const ModelImport = {
    $type: 'ModelImport',
    path: 'path'
} as const;

export function isModelImport(item: unknown): item is ModelImport {
    return reflection.isInstance(item, ModelImport.$type);
}

export interface NullExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'NullExpr';
    value: 'null';
}

export const NullExpr = {
    $type: 'NullExpr',
    value: 'value'
} as const;

export function isNullExpr(item: unknown): item is NullExpr {
    return reflection.isInstance(item, NullExpr.$type);
}

export interface NumberLiteral extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigArrayExpr | ConfigField | ConfigInvocationArg | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr | UnsupportedFieldType;
    readonly $type: 'NumberLiteral';
    value: string;
}

export const NumberLiteral = {
    $type: 'NumberLiteral',
    value: 'value'
} as const;

export function isNumberLiteral(item: unknown): item is NumberLiteral {
    return reflection.isInstance(item, NumberLiteral.$type);
}

export interface ObjectExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr;
    readonly $type: 'ObjectExpr';
    fields: Array<FieldInitializer>;
}

export const ObjectExpr = {
    $type: 'ObjectExpr',
    fields: 'fields'
} as const;

export function isObjectExpr(item: unknown): item is ObjectExpr {
    return reflection.isInstance(item, ObjectExpr.$type);
}

export interface Plugin extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'Plugin';
    fields: Array<PluginField>;
    name: RegularID;
}

export const Plugin = {
    $type: 'Plugin',
    fields: 'fields',
    name: 'name'
} as const;

export function isPlugin(item: unknown): item is Plugin {
    return reflection.isInstance(item, Plugin.$type);
}

export interface PluginField extends langium.AstNode {
    readonly $container: Plugin;
    readonly $type: 'PluginField';
    name: RegularID;
    value: ArrayExpr | LiteralExpr | ObjectExpr;
}

export const PluginField = {
    $type: 'PluginField',
    name: 'name',
    value: 'value'
} as const;

export function isPluginField(item: unknown): item is PluginField {
    return reflection.isInstance(item, PluginField.$type);
}

export interface Procedure extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'Procedure';
    attributes: Array<InternalAttribute>;
    mutation: boolean;
    name: RegularID;
    params: Array<ProcedureParam>;
    returnType: FunctionParamType;
}

export const Procedure = {
    $type: 'Procedure',
    attributes: 'attributes',
    mutation: 'mutation',
    name: 'name',
    params: 'params',
    returnType: 'returnType'
} as const;

export function isProcedure(item: unknown): item is Procedure {
    return reflection.isInstance(item, Procedure.$type);
}

export interface ProcedureParam extends langium.AstNode {
    readonly $container: Procedure;
    readonly $type: 'ProcedureParam';
    name: RegularID;
    optional: boolean;
    type: FunctionParamType;
}

export const ProcedureParam = {
    $type: 'ProcedureParam',
    name: 'name',
    optional: 'optional',
    type: 'type'
} as const;

export function isProcedureParam(item: unknown): item is ProcedureParam {
    return reflection.isInstance(item, ProcedureParam.$type);
}

export interface ReferenceArg extends langium.AstNode {
    readonly $container: ReferenceExpr;
    readonly $type: 'ReferenceArg';
    name: string;
    value: Expression;
}

export const ReferenceArg = {
    $type: 'ReferenceArg',
    name: 'name',
    value: 'value'
} as const;

export function isReferenceArg(item: unknown): item is ReferenceArg {
    return reflection.isInstance(item, ReferenceArg.$type);
}

export interface ReferenceExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'ReferenceExpr';
    args: Array<ReferenceArg>;
    target: langium.Reference<ReferenceTarget>;
}

export const ReferenceExpr = {
    $type: 'ReferenceExpr',
    args: 'args',
    target: 'target'
} as const;

export function isReferenceExpr(item: unknown): item is ReferenceExpr {
    return reflection.isInstance(item, ReferenceExpr.$type);
}

export type ReferenceTarget = CollectionPredicateBinding | DataField | EnumField | FunctionParam;

export const ReferenceTarget = {
    $type: 'ReferenceTarget'
} as const;

export function isReferenceTarget(item: unknown): item is ReferenceTarget {
    return reflection.isInstance(item, ReferenceTarget.$type);
}

export type RegularID = 'abstract' | 'attribute' | 'datasource' | 'enum' | 'import' | 'in' | 'model' | 'plugin' | 'type' | 'view' | string;

export function isRegularID(item: unknown): item is RegularID {
    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)));
}

export type RegularIDWithTypeNames = 'Any' | 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'Null' | 'Object' | 'String' | 'Unsupported' | 'Void' | RegularID;

export function isRegularIDWithTypeNames(item: unknown): item is RegularIDWithTypeNames {
    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';
}

export interface StringLiteral extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | ConfigArrayExpr | ConfigField | ConfigInvocationArg | FieldInitializer | FunctionDecl | MemberAccessExpr | PluginField | ReferenceArg | UnaryExpr | UnsupportedFieldType;
    readonly $type: 'StringLiteral';
    value: string;
}

export const StringLiteral = {
    $type: 'StringLiteral',
    value: 'value'
} as const;

export function isStringLiteral(item: unknown): item is StringLiteral {
    return reflection.isInstance(item, StringLiteral.$type);
}

export interface ThisExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'ThisExpr';
    value: 'this';
}

export const ThisExpr = {
    $type: 'ThisExpr',
    value: 'value'
} as const;

export function isThisExpr(item: unknown): item is ThisExpr {
    return reflection.isInstance(item, ThisExpr.$type);
}

export type TypeDeclaration = DataModel | Enum | TypeDef;

export const TypeDeclaration = {
    $type: 'TypeDeclaration'
} as const;

export function isTypeDeclaration(item: unknown): item is TypeDeclaration {
    return reflection.isInstance(item, TypeDeclaration.$type);
}

export interface TypeDef extends langium.AstNode {
    readonly $container: Model;
    readonly $type: 'TypeDef';
    attributes: Array<DataModelAttribute>;
    comments: Array<string>;
    fields: Array<DataField>;
    mixins: Array<langium.Reference<TypeDef>>;
    name: RegularID;
}

export const TypeDef = {
    $type: 'TypeDef',
    attributes: 'attributes',
    comments: 'comments',
    fields: 'fields',
    mixins: 'mixins',
    name: 'name'
} as const;

export function isTypeDef(item: unknown): item is TypeDef {
    return reflection.isInstance(item, TypeDef.$type);
}

export interface UnaryExpr extends langium.AstNode {
    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | FieldInitializer | FunctionDecl | MemberAccessExpr | ReferenceArg | UnaryExpr;
    readonly $type: 'UnaryExpr';
    operand: Expression;
    operator: '!';
}

export const UnaryExpr = {
    $type: 'UnaryExpr',
    operand: 'operand',
    operator: 'operator'
} as const;

export function isUnaryExpr(item: unknown): item is UnaryExpr {
    return reflection.isInstance(item, UnaryExpr.$type);
}

export interface UnsupportedFieldType extends langium.AstNode {
    readonly $container: DataFieldType;
    readonly $type: 'UnsupportedFieldType';
    value: LiteralExpr;
}

export const UnsupportedFieldType = {
    $type: 'UnsupportedFieldType',
    value: 'value'
} as const;

export function isUnsupportedFieldType(item: unknown): item is UnsupportedFieldType {
    return reflection.isInstance(item, UnsupportedFieldType.$type);
}

export type ZModelAstType = {
    AbstractDeclaration: AbstractDeclaration
    Argument: Argument
    ArrayExpr: ArrayExpr
    Attribute: Attribute
    AttributeArg: AttributeArg
    AttributeParam: AttributeParam
    AttributeParamType: AttributeParamType
    BinaryExpr: BinaryExpr
    BooleanLiteral: BooleanLiteral
    CollectionPredicateBinding: CollectionPredicateBinding
    ConfigArrayExpr: ConfigArrayExpr
    ConfigExpr: ConfigExpr
    ConfigField: ConfigField
    ConfigInvocationArg: ConfigInvocationArg
    ConfigInvocationExpr: ConfigInvocationExpr
    DataField: DataField
    DataFieldAttribute: DataFieldAttribute
    DataFieldParam: DataFieldParam
    DataFieldType: DataFieldType
    DataModel: DataModel
    DataModelAttribute: DataModelAttribute
    DataSource: DataSource
    Enum: Enum
    EnumField: EnumField
    Expression: Expression
    FieldInitializer: FieldInitializer
    FunctionDecl: FunctionDecl
    FunctionParam: FunctionParam
    FunctionParamType: FunctionParamType
    GeneratorDecl: GeneratorDecl
    InternalAttribute: InternalAttribute
    InvocationExpr: InvocationExpr
    LiteralExpr: LiteralExpr
    MemberAccessExpr: MemberAccessExpr
    MemberAccessTarget: MemberAccessTarget
    Model: Model
    ModelImport: ModelImport
    NullExpr: NullExpr
    NumberLiteral: NumberLiteral
    ObjectExpr: ObjectExpr
    Plugin: Plugin
    PluginField: PluginField
    Procedure: Procedure
    ProcedureParam: ProcedureParam
    ReferenceArg: ReferenceArg
    ReferenceExpr: ReferenceExpr
    ReferenceTarget: ReferenceTarget
    StringLiteral: StringLiteral
    ThisExpr: ThisExpr
    TypeDeclaration: TypeDeclaration
    TypeDef: TypeDef
    UnaryExpr: UnaryExpr
    UnsupportedFieldType: UnsupportedFieldType
}

export class ZModelAstReflection extends langium.AbstractAstReflection {
    override readonly 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
                },
                params: {
                    name: DataField.params,
                    defaultValue: []
                },
                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: []
        },
        DataFieldParam: {
            name: DataFieldParam.$type,
            properties: {
                name: {
                    name: DataFieldParam.name
                },
                optional: {
                    name: DataFieldParam.optional,
                    defaultValue: false
                },
                type: {
                    name: DataFieldParam.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: []
        }
    } as const satisfies langium.AstMetaData
}

export const reflection = new ZModelAstReflection();