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

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

export const DomainModelTerminals = {
    WS: /\s+/,
    ID: /[_a-zA-Z][\w_]*/,
    ML_COMMENT: /\/\*[\s\S]*?\*\//,
    SL_COMMENT: /\/\/[^\n\r]*/,
};

export type DomainModelTerminalNames = keyof typeof DomainModelTerminals;

export type DomainModelKeywordNames =
    | "."
    | ":"
    | "datatype"
    | "entity"
    | "extends"
    | "many"
    | "package"
    | "{"
    | "}";

export type DomainModelTokenNames = DomainModelTerminalNames | DomainModelKeywordNames;

export type AbstractElement = PackageDeclaration | Type;

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

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

export interface DataType extends langium.AstNode {
    readonly $container: Domainmodel | PackageDeclaration;
    readonly $type: 'DataType';
    name: string;
}

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

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

export interface Domainmodel extends langium.AstNode {
    readonly $type: 'Domainmodel';
    elements: Array<AbstractElement>;
}

export const Domainmodel = {
    $type: 'Domainmodel',
    elements: 'elements'
} as const;

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

export interface Entity extends langium.AstNode {
    readonly $container: Domainmodel | PackageDeclaration;
    readonly $type: 'Entity';
    features: Array<Feature>;
    name: string;
    superType?: langium.MultiReference<Entity>;
}

export const Entity = {
    $type: 'Entity',
    features: 'features',
    name: 'name',
    superType: 'superType'
} as const;

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

export interface Feature extends langium.AstNode {
    readonly $container: Entity;
    readonly $type: 'Feature';
    many: boolean;
    name: string;
    type: langium.Reference<Type>;
}

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

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

export interface PackageDeclaration extends langium.AstNode {
    readonly $container: Domainmodel | PackageDeclaration;
    readonly $type: 'PackageDeclaration';
    elements: Array<AbstractElement>;
    name: QualifiedName;
}

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

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

export type QualifiedName = string;

export function isQualifiedName(item: unknown): item is QualifiedName {
    return typeof item === 'string';
}

export type Type = DataType | Entity;

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

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

export type DomainModelAstType = {
    AbstractElement: AbstractElement
    DataType: DataType
    Domainmodel: Domainmodel
    Entity: Entity
    Feature: Feature
    PackageDeclaration: PackageDeclaration
    Type: Type
}

export class DomainModelAstReflection extends langium.AbstractAstReflection {
    override readonly types = {
        AbstractElement: {
            name: AbstractElement.$type,
            properties: {
            },
            superTypes: []
        },
        DataType: {
            name: DataType.$type,
            properties: {
                name: {
                    name: DataType.name
                }
            },
            superTypes: [Type.$type]
        },
        Domainmodel: {
            name: Domainmodel.$type,
            properties: {
                elements: {
                    name: Domainmodel.elements,
                    defaultValue: [],
                    optional: true
                }
            },
            superTypes: []
        },
        Entity: {
            name: Entity.$type,
            properties: {
                features: {
                    name: Entity.features,
                    defaultValue: [],
                    optional: true
                },
                name: {
                    name: Entity.name
                },
                superType: {
                    name: Entity.superType,
                    referenceType: Entity.$type,
                    optional: true
                }
            },
            superTypes: [Type.$type]
        },
        Feature: {
            name: Feature.$type,
            properties: {
                many: {
                    name: Feature.many,
                    defaultValue: false,
                    optional: true
                },
                name: {
                    name: Feature.name
                },
                type: {
                    name: Feature.type,
                    referenceType: Type.$type
                }
            },
            superTypes: []
        },
        PackageDeclaration: {
            name: PackageDeclaration.$type,
            properties: {
                elements: {
                    name: PackageDeclaration.elements,
                    defaultValue: [],
                    optional: true
                },
                name: {
                    name: PackageDeclaration.name
                }
            },
            superTypes: [AbstractElement.$type]
        },
        Type: {
            name: Type.$type,
            properties: {
            },
            superTypes: [AbstractElement.$type]
        }
    } as const satisfies langium.AstMetaData
}

export const reflection = new DomainModelAstReflection();