zenstack 1.0.0 → 1.0.16

package/packages/schema/src/language-server/generated/ast.ts

@@ -1,603 +0,0 @@
-/******************************************************************************
- * This file was generated by langium-cli 0.4.0.
- * DO NOT EDIT MANUALLY!
- ******************************************************************************/
-
-/* eslint-disable @typescript-eslint/array-type */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-import { AstNode, AstReflection, Reference, isAstNode, TypeMetaData } from 'langium';
-
-export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | Function;
-
-export const AbstractDeclaration = 'AbstractDeclaration';
-
-export function isAbstractDeclaration(item: unknown): item is AbstractDeclaration {
-    return reflection.isInstance(item, AbstractDeclaration);
-}
-
-export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ReferenceExpr | ThisExpr | UnaryExpr;
-
-export const Expression = 'Expression';
-
-export function isExpression(item: unknown): item is Expression {
-    return reflection.isInstance(item, Expression);
-}
-
-export type ReferenceTarget = DataModelField | EnumField | FunctionParam;
-
-export const ReferenceTarget = 'ReferenceTarget';
-
-export function isReferenceTarget(item: unknown): item is ReferenceTarget {
-    return reflection.isInstance(item, ReferenceTarget);
-}
-
-export type TypeDeclaration = DataModel | Enum;
-
-export const TypeDeclaration = 'TypeDeclaration';
-
-export function isTypeDeclaration(item: unknown): item is TypeDeclaration {
-    return reflection.isInstance(item, TypeDeclaration);
-}
-
-export interface Argument extends AstNode {
-    readonly $container: InvocationExpr;
-    name?: string
-    value: Expression
-}
-
-export const Argument = 'Argument';
-
-export function isArgument(item: unknown): item is Argument {
-    return reflection.isInstance(item, Argument);
-}
-
-export interface ArrayExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    items: Array<Expression>
-}
-
-export const ArrayExpr = 'ArrayExpr';
-
-export function isArrayExpr(item: unknown): item is ArrayExpr {
-    return reflection.isInstance(item, ArrayExpr);
-}
-
-export interface Attribute extends AstNode {
-    readonly $container: Model;
-    name: string
-    params: Array<AttributeParam>
-}
-
-export const Attribute = 'Attribute';
-
-export function isAttribute(item: unknown): item is Attribute {
-    return reflection.isInstance(item, Attribute);
-}
-
-export interface AttributeArg extends AstNode {
-    readonly $container: DataModelAttribute | DataModelFieldAttribute;
-    name?: string
-    value: Expression
-}
-
-export const AttributeArg = 'AttributeArg';
-
-export function isAttributeArg(item: unknown): item is AttributeArg {
-    return reflection.isInstance(item, AttributeArg);
-}
-
-export interface AttributeParam extends AstNode {
-    readonly $container: Attribute;
-    name: string
-    positional: boolean
-    type: AttributeParamType
-}
-
-export const AttributeParam = 'AttributeParam';
-
-export function isAttributeParam(item: unknown): item is AttributeParam {
-    return reflection.isInstance(item, AttributeParam);
-}
-
-export interface AttributeParamType extends AstNode {
-    readonly $container: AttributeParam;
-    array: boolean
-    optional: boolean
-    type: 'Boolean' | 'DateTime' | 'FieldReference' | 'Int' | 'JSON' | 'String'
-}
-
-export const AttributeParamType = 'AttributeParamType';
-
-export function isAttributeParamType(item: unknown): item is AttributeParamType {
-    return reflection.isInstance(item, AttributeParamType);
-}
-
-export interface BinaryExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    left: Expression
-    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | '||'
-    right: Expression
-}
-
-export const BinaryExpr = 'BinaryExpr';
-
-export function isBinaryExpr(item: unknown): item is BinaryExpr {
-    return reflection.isInstance(item, BinaryExpr);
-}
-
-export interface DataModel extends AstNode {
-    readonly $container: Model;
-    attributes: Array<DataModelAttribute>
-    fields: Array<DataModelField>
-    name: string
-}
-
-export const DataModel = 'DataModel';
-
-export function isDataModel(item: unknown): item is DataModel {
-    return reflection.isInstance(item, DataModel);
-}
-
-export interface DataModelAttribute extends AstNode {
-    readonly $container: DataModel;
-    args: Array<AttributeArg>
-    decl: Reference<Attribute>
-}
-
-export const DataModelAttribute = 'DataModelAttribute';
-
-export function isDataModelAttribute(item: unknown): item is DataModelAttribute {
-    return reflection.isInstance(item, DataModelAttribute);
-}
-
-export interface DataModelField extends AstNode {
-    readonly $container: DataModel;
-    attributes: Array<DataModelFieldAttribute>
-    name: string
-    type: DataModelFieldType
-}
-
-export const DataModelField = 'DataModelField';
-
-export function isDataModelField(item: unknown): item is DataModelField {
-    return reflection.isInstance(item, DataModelField);
-}
-
-export interface DataModelFieldAttribute extends AstNode {
-    readonly $container: DataModelField;
-    args: Array<AttributeArg>
-    decl: Reference<Attribute>
-}
-
-export const DataModelFieldAttribute = 'DataModelFieldAttribute';
-
-export function isDataModelFieldAttribute(item: unknown): item is DataModelFieldAttribute {
-    return reflection.isInstance(item, DataModelFieldAttribute);
-}
-
-export interface DataModelFieldType extends AstNode {
-    readonly $container: DataModelField;
-    array: boolean
-    optional: boolean
-    reference?: Reference<TypeDeclaration>
-    type?: 'Boolean' | 'DateTime' | 'Int' | 'JSON' | 'String'
-}
-
-export const DataModelFieldType = 'DataModelFieldType';
-
-export function isDataModelFieldType(item: unknown): item is DataModelFieldType {
-    return reflection.isInstance(item, DataModelFieldType);
-}
-
-export interface DataSource extends AstNode {
-    readonly $container: Model;
-    fields: Array<DataSourceField>
-    name: string
-}
-
-export const DataSource = 'DataSource';
-
-export function isDataSource(item: unknown): item is DataSource {
-    return reflection.isInstance(item, DataSource);
-}
-
-export interface DataSourceField extends AstNode {
-    readonly $container: DataSource;
-    name: string
-    value: InvocationExpr | LiteralExpr
-}
-
-export const DataSourceField = 'DataSourceField';
-
-export function isDataSourceField(item: unknown): item is DataSourceField {
-    return reflection.isInstance(item, DataSourceField);
-}
-
-export interface Enum extends AstNode {
-    readonly $container: Model;
-    fields: Array<EnumField>
-    name: string
-}
-
-export const Enum = 'Enum';
-
-export function isEnum(item: unknown): item is Enum {
-    return reflection.isInstance(item, Enum);
-}
-
-export interface EnumField extends AstNode {
-    readonly $container: Enum;
-    name: string
-}
-
-export const EnumField = 'EnumField';
-
-export function isEnumField(item: unknown): item is EnumField {
-    return reflection.isInstance(item, EnumField);
-}
-
-export interface Function extends AstNode {
-    readonly $container: Model;
-    expression?: Expression
-    name: string
-    params: Array<FunctionParam>
-    returnType: FunctionParamType
-}
-
-export const Function = 'Function';
-
-export function isFunction(item: unknown): item is Function {
-    return reflection.isInstance(item, Function);
-}
-
-export interface FunctionParam extends AstNode {
-    readonly $container: Function;
-    name: string
-    type: FunctionParamType
-}
-
-export const FunctionParam = 'FunctionParam';
-
-export function isFunctionParam(item: unknown): item is FunctionParam {
-    return reflection.isInstance(item, FunctionParam);
-}
-
-export interface FunctionParamType extends AstNode {
-    readonly $container: Function | FunctionParam;
-    array: boolean
-    reference?: Reference<TypeDeclaration>
-    type?: 'Boolean' | 'DateTime' | 'Int' | 'JSON' | 'String'
-}
-
-export const FunctionParamType = 'FunctionParamType';
-
-export function isFunctionParamType(item: unknown): item is FunctionParamType {
-    return reflection.isInstance(item, FunctionParamType);
-}
-
-export interface InvocationExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    args: Array<Argument>
-    function: Reference<Function>
-}
-
-export const InvocationExpr = 'InvocationExpr';
-
-export function isInvocationExpr(item: unknown): item is InvocationExpr {
-    return reflection.isInstance(item, InvocationExpr);
-}
-
-export interface LiteralExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    value: boolean | number | string
-}
-
-export const LiteralExpr = 'LiteralExpr';
-
-export function isLiteralExpr(item: unknown): item is LiteralExpr {
-    return reflection.isInstance(item, LiteralExpr);
-}
-
-export interface MemberAccessExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    member: Reference<DataModelField>
-    operand: Expression
-}
-
-export const MemberAccessExpr = 'MemberAccessExpr';
-
-export function isMemberAccessExpr(item: unknown): item is MemberAccessExpr {
-    return reflection.isInstance(item, MemberAccessExpr);
-}
-
-export interface Model extends AstNode {
-    declarations: Array<AbstractDeclaration>
-}
-
-export const Model = 'Model';
-
-export function isModel(item: unknown): item is Model {
-    return reflection.isInstance(item, Model);
-}
-
-export interface NullExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    value: string
-}
-
-export const NullExpr = 'NullExpr';
-
-export function isNullExpr(item: unknown): item is NullExpr {
-    return reflection.isInstance(item, NullExpr);
-}
-
-export interface ReferenceArg extends AstNode {
-    readonly $container: ReferenceExpr;
-    name: 'sort'
-    value: 'Asc' | 'Desc'
-}
-
-export const ReferenceArg = 'ReferenceArg';
-
-export function isReferenceArg(item: unknown): item is ReferenceArg {
-    return reflection.isInstance(item, ReferenceArg);
-}
-
-export interface ReferenceExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    args: Array<ReferenceArg>
-    target: Reference<ReferenceTarget>
-}
-
-export const ReferenceExpr = 'ReferenceExpr';
-
-export function isReferenceExpr(item: unknown): item is ReferenceExpr {
-    return reflection.isInstance(item, ReferenceExpr);
-}
-
-export interface ThisExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    value: string
-}
-
-export const ThisExpr = 'ThisExpr';
-
-export function isThisExpr(item: unknown): item is ThisExpr {
-    return reflection.isInstance(item, ThisExpr);
-}
-
-export interface UnaryExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | MemberAccessExpr | UnaryExpr;
-    operand: Expression
-    operator: '!'
-}
-
-export const UnaryExpr = 'UnaryExpr';
-
-export function isUnaryExpr(item: unknown): item is UnaryExpr {
-    return reflection.isInstance(item, UnaryExpr);
-}
-
-export type ZModelAstType = 'AbstractDeclaration' | 'Argument' | 'ArrayExpr' | 'Attribute' | 'AttributeArg' | 'AttributeParam' | 'AttributeParamType' | 'BinaryExpr' | 'DataModel' | 'DataModelAttribute' | 'DataModelField' | 'DataModelFieldAttribute' | 'DataModelFieldType' | 'DataSource' | 'DataSourceField' | 'Enum' | 'EnumField' | 'Expression' | 'Function' | 'FunctionParam' | 'FunctionParamType' | 'InvocationExpr' | 'LiteralExpr' | 'MemberAccessExpr' | 'Model' | 'NullExpr' | 'ReferenceArg' | 'ReferenceExpr' | 'ReferenceTarget' | 'ThisExpr' | 'TypeDeclaration' | 'UnaryExpr';
-
-export type ZModelAstReference = 'DataModelAttribute:decl' | 'DataModelFieldAttribute:decl' | 'DataModelFieldType:reference' | 'FunctionParamType:reference' | 'InvocationExpr:function' | 'MemberAccessExpr:member' | 'ReferenceExpr:target';
-
-export class ZModelAstReflection implements AstReflection {
-
-    getAllTypes(): string[] {
-        return ['AbstractDeclaration', 'Argument', 'ArrayExpr', 'Attribute', 'AttributeArg', 'AttributeParam', 'AttributeParamType', 'BinaryExpr', 'DataModel', 'DataModelAttribute', 'DataModelField', 'DataModelFieldAttribute', 'DataModelFieldType', 'DataSource', 'DataSourceField', 'Enum', 'EnumField', 'Expression', 'Function', 'FunctionParam', 'FunctionParamType', 'InvocationExpr', 'LiteralExpr', 'MemberAccessExpr', 'Model', 'NullExpr', 'ReferenceArg', 'ReferenceExpr', 'ReferenceTarget', 'ThisExpr', 'TypeDeclaration', 'UnaryExpr'];
-    }
-
-    isInstance(node: unknown, type: string): boolean {
-        return isAstNode(node) && this.isSubtype(node.$type, type);
-    }
-
-    isSubtype(subtype: string, supertype: string): boolean {
-        if (subtype === supertype) {
-            return true;
-        }
-        switch (subtype) {
-            case ArrayExpr:
-            case BinaryExpr:
-            case InvocationExpr:
-            case LiteralExpr:
-            case MemberAccessExpr:
-            case NullExpr:
-            case ReferenceExpr:
-            case ThisExpr:
-            case UnaryExpr: {
-                return this.isSubtype(Expression, supertype);
-            }
-            case Attribute:
-            case DataSource:
-            case Function: {
-                return this.isSubtype(AbstractDeclaration, supertype);
-            }
-            case DataModel:
-            case Enum: {
-                return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
-            }
-            case DataModelField:
-            case EnumField:
-            case FunctionParam: {
-                return this.isSubtype(ReferenceTarget, supertype);
-            }
-            default: {
-                return false;
-            }
-        }
-    }
-
-    getReferenceType(referenceId: ZModelAstReference): string {
-        switch (referenceId) {
-            case 'DataModelAttribute:decl': {
-                return Attribute;
-            }
-            case 'DataModelFieldAttribute:decl': {
-                return Attribute;
-            }
-            case 'DataModelFieldType:reference': {
-                return TypeDeclaration;
-            }
-            case 'FunctionParamType:reference': {
-                return TypeDeclaration;
-            }
-            case 'InvocationExpr:function': {
-                return Function;
-            }
-            case 'MemberAccessExpr:member': {
-                return DataModelField;
-            }
-            case 'ReferenceExpr:target': {
-                return ReferenceTarget;
-            }
-            default: {
-                throw new Error(`${referenceId} is not a valid reference id.`);
-            }
-        }
-    }
-
-    getTypeMetaData(type: string): TypeMetaData {
-        switch (type) {
-            case 'ArrayExpr': {
-                return {
-                    name: 'ArrayExpr',
-                    mandatory: [
-                        { name: 'items', type: 'array' }
-                    ]
-                };
-            }
-            case 'Attribute': {
-                return {
-                    name: 'Attribute',
-                    mandatory: [
-                        { name: 'params', type: 'array' }
-                    ]
-                };
-            }
-            case 'AttributeParam': {
-                return {
-                    name: 'AttributeParam',
-                    mandatory: [
-                        { name: 'positional', type: 'boolean' }
-                    ]
-                };
-            }
-            case 'AttributeParamType': {
-                return {
-                    name: 'AttributeParamType',
-                    mandatory: [
-                        { name: 'array', type: 'boolean' },
-                        { name: 'optional', type: 'boolean' }
-                    ]
-                };
-            }
-            case 'DataModel': {
-                return {
-                    name: 'DataModel',
-                    mandatory: [
-                        { name: 'attributes', type: 'array' },
-                        { name: 'fields', type: 'array' }
-                    ]
-                };
-            }
-            case 'DataModelAttribute': {
-                return {
-                    name: 'DataModelAttribute',
-                    mandatory: [
-                        { name: 'args', type: 'array' }
-                    ]
-                };
-            }
-            case 'DataModelField': {
-                return {
-                    name: 'DataModelField',
-                    mandatory: [
-                        { name: 'attributes', type: 'array' }
-                    ]
-                };
-            }
-            case 'DataModelFieldAttribute': {
-                return {
-                    name: 'DataModelFieldAttribute',
-                    mandatory: [
-                        { name: 'args', type: 'array' }
-                    ]
-                };
-            }
-            case 'DataModelFieldType': {
-                return {
-                    name: 'DataModelFieldType',
-                    mandatory: [
-                        { name: 'array', type: 'boolean' },
-                        { name: 'optional', type: 'boolean' }
-                    ]
-                };
-            }
-            case 'DataSource': {
-                return {
-                    name: 'DataSource',
-                    mandatory: [
-                        { name: 'fields', type: 'array' }
-                    ]
-                };
-            }
-            case 'Enum': {
-                return {
-                    name: 'Enum',
-                    mandatory: [
-                        { name: 'fields', type: 'array' }
-                    ]
-                };
-            }
-            case 'Function': {
-                return {
-                    name: 'Function',
-                    mandatory: [
-                        { name: 'params', type: 'array' }
-                    ]
-                };
-            }
-            case 'FunctionParamType': {
-                return {
-                    name: 'FunctionParamType',
-                    mandatory: [
-                        { name: 'array', type: 'boolean' }
-                    ]
-                };
-            }
-            case 'InvocationExpr': {
-                return {
-                    name: 'InvocationExpr',
-                    mandatory: [
-                        { name: 'args', type: 'array' }
-                    ]
-                };
-            }
-            case 'Model': {
-                return {
-                    name: 'Model',
-                    mandatory: [
-                        { name: 'declarations', type: 'array' }
-                    ]
-                };
-            }
-            case 'ReferenceExpr': {
-                return {
-                    name: 'ReferenceExpr',
-                    mandatory: [
-                        { name: 'args', type: 'array' }
-                    ]
-                };
-            }
-            default: {
-                return {
-                    name: type,
-                    mandatory: []
-                };
-            }
-        }
-    }
-}
-
-export const reflection = new ZModelAstReflection();