@zenstackhq/language 0.6.0-pre.2 → 1.0.0-alpha.100

package/README.md

@@ -0,0 +1,5 @@
+# ZenStack ZModel language compiler
+
+This package provides the AST of ZModel - ZenStack's modeling language.
+
+Visit [Homepage](https://zenstack.dev) for more details.

package/ast.d.ts

@@ -1,2 +1,32 @@
+import { AbstractDeclaration, ExpressionType, BinaryExpr } from './generated/ast';
 export * from './generated/ast';
 export { AstNode, Reference } from 'langium';
+/**
+ * Shape of type resolution result: an expression type or reference to a declaration
+ */
+export type ResolvedShape = ExpressionType | AbstractDeclaration;
+/**
+ * Resolved type information (attached to expressions by linker)
+ */
+export type ResolvedType = {
+    decl?: ResolvedShape;
+    array?: boolean;
+    nullable?: boolean;
+};
+export declare const BinaryExprOperatorPriority: Record<BinaryExpr['operator'], number>;
+declare module './generated/ast' {
+    interface AttributeArg {
+        /**
+         * Resolved attribute param declaration
+         */
+        $resolvedParam?: AttributeParam;
+    }
+}
+declare module 'langium' {
+    interface AstNode {
+        /**
+         * Resolved type information attached to expressions
+         */
+        $resolvedType?: ResolvedType;
+    }
+}

package/ast.js

@@ -14,5 +14,24 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryExprOperatorPriority = void 0;
 __exportStar(require("./generated/ast"), exports);
+exports.BinaryExprOperatorPriority = {
+    //LogicalExpr
+    '||': 1,
+    '&&': 1,
+    //EqualityExpr
+    '==': 2,
+    '!=': 2,
+    //ComparisonExpr
+    '>': 3,
+    '<': 3,
+    '>=': 3,
+    '<=': 3,
+    in: 4,
+    //CollectionPredicateExpr
+    '^': 5,
+    '?': 5,
+    '!': 5,
+};
 //# sourceMappingURL=ast.js.map

package/ast.js.map

@@ -1 +1 @@
-{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC"}
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAEA,kDAAgC;AAiBnB,QAAA,0BAA0B,GAA2C;IAC9E,aAAa;IACb,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,cAAc;IACd,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,gBAAgB;IAChB,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,IAAI,EAAE,CAAC;IACP,IAAI,EAAE,CAAC;IACP,EAAE,EAAE,CAAC;IACL,yBAAyB;IACzB,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;IACN,GAAG,EAAE,CAAC;CACT,CAAC"}

package/generated/ast.d.ts

@@ -1,41 +1,46 @@
 /******************************************************************************
- * This file was generated by langium-cli 0.5.0.
+ * This file was generated by langium-cli 1.1.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
-import { AstNode, AstReflection, Reference, ReferenceInfo, TypeMetaData } from 'langium';
-export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | Function | Generator | Plugin;
+import { AstNode, AbstractAstReflection, Reference, ReferenceInfo, TypeMetaData } from 'langium';
+export type AbstractDeclaration = Attribute | DataModel | DataSource | Enum | FunctionDecl | GeneratorDecl | Plugin;
 export declare const AbstractDeclaration = "AbstractDeclaration";
 export declare function isAbstractDeclaration(item: unknown): item is AbstractDeclaration;
 export type AttributeAttributeName = string;
-export type AttributeName = string;
+export type AttributeName = AttributeAttributeName | DataModelAttributeName | DataModelFieldAttributeName;
 export type BuiltinType = 'BigInt' | 'Boolean' | 'Bytes' | 'DateTime' | 'Decimal' | 'Float' | 'Int' | 'Json' | 'String';
 export type DataModelAttributeName = string;
 export type DataModelFieldAttributeName = string;
-export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ReferenceExpr | ThisExpr | UnaryExpr;
+export type Expression = ArrayExpr | BinaryExpr | InvocationExpr | LiteralExpr | MemberAccessExpr | NullExpr | ObjectExpr | ReferenceExpr | ThisExpr | UnaryExpr;
 export declare const Expression = "Expression";
 export declare function isExpression(item: unknown): item is Expression;
-export type ExpressionType = 'Any' | 'Boolean' | 'DateTime' | 'Float' | 'Int' | 'Null' | 'String';
+export type ExpressionType = 'Any' | 'Boolean' | 'DateTime' | 'Float' | 'Int' | 'Null' | 'Object' | 'String';
+export type QualifiedName = string;
 export type ReferenceTarget = DataModelField | EnumField | FunctionParam;
 export declare const ReferenceTarget = "ReferenceTarget";
 export declare function isReferenceTarget(item: unknown): item is ReferenceTarget;
+export type RegularID = 'in' | string;
 export type TypeDeclaration = DataModel | Enum;
 export declare const TypeDeclaration = "TypeDeclaration";
 export declare function isTypeDeclaration(item: unknown): item is TypeDeclaration;
 export interface Argument extends AstNode {
     readonly $container: InvocationExpr;
-    name?: string;
+    readonly $type: 'Argument';
+    name?: RegularID;
     value: Expression;
 }
 export declare const Argument = "Argument";
 export declare function isArgument(item: unknown): item is Argument;
 export interface ArrayExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'ArrayExpr';
     items: Array<Expression>;
 }
 export declare const ArrayExpr = "ArrayExpr";
 export declare function isArrayExpr(item: unknown): item is ArrayExpr;
 export interface Attribute extends AstNode {
     readonly $container: Model;
+    readonly $type: 'Attribute';
     attributes: Array<AttributeAttribute>;
     name: AttributeName;
     params: Array<AttributeParam>;
@@ -44,13 +49,15 @@ export declare const Attribute = "Attribute";
 export declare function isAttribute(item: unknown): item is Attribute;
 export interface AttributeArg extends AstNode {
     readonly $container: AttributeAttribute | DataModelAttribute | DataModelFieldAttribute;
-    name?: string;
+    readonly $type: 'AttributeArg';
+    name?: RegularID;
     value: Expression;
 }
 export declare const AttributeArg = "AttributeArg";
 export declare function isAttributeArg(item: unknown): item is AttributeArg;
 export interface AttributeAttribute extends AstNode {
     readonly $container: Attribute;
+    readonly $type: 'AttributeAttribute';
     args: Array<AttributeArg>;
     decl: Reference<Attribute>;
 }
@@ -58,54 +65,63 @@ export declare const AttributeAttribute = "AttributeAttribute";
 export declare function isAttributeAttribute(item: unknown): item is AttributeAttribute;
 export interface AttributeParam extends AstNode {
     readonly $container: Attribute;
+    readonly $type: 'AttributeParam';
     default: boolean;
-    name: string;
+    name: RegularID;
     type: AttributeParamType;
 }
 export declare const AttributeParam = "AttributeParam";
 export declare function isAttributeParam(item: unknown): item is AttributeParam;
 export interface AttributeParamType extends AstNode {
     readonly $container: AttributeParam;
+    readonly $type: 'AttributeParamType';
     array: boolean;
     optional: boolean;
     reference?: Reference<TypeDeclaration>;
-    type?: 'ContextType' | 'FieldReference' | ExpressionType;
+    type?: 'ContextType' | 'FieldReference' | 'TransitiveFieldReference' | ExpressionType;
 }
 export declare const AttributeParamType = "AttributeParamType";
 export declare function isAttributeParamType(item: unknown): item is AttributeParamType;
 export interface BinaryExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'BinaryExpr';
     left: Expression;
-    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | '||';
+    operator: '!' | '!=' | '&&' | '<' | '<=' | '==' | '>' | '>=' | '?' | '^' | 'in' | '||';
     right: Expression;
 }
 export declare const BinaryExpr = "BinaryExpr";
 export declare function isBinaryExpr(item: unknown): item is BinaryExpr;
 export interface DataModel extends AstNode {
     readonly $container: Model;
+    readonly $type: 'DataModel';
     attributes: Array<DataModelAttribute>;
+    comments: Array<string>;
     fields: Array<DataModelField>;
-    name: string;
+    name: RegularID;
 }
 export declare const DataModel = "DataModel";
 export declare function isDataModel(item: unknown): item is DataModel;
 export interface DataModelAttribute extends AstNode {
-    readonly $container: DataModel;
+    readonly $container: DataModel | Enum;
+    readonly $type: 'DataModelAttribute';
     args: Array<AttributeArg>;
     decl: Reference<Attribute>;
 }
 export declare const DataModelAttribute = "DataModelAttribute";
 export declare function isDataModelAttribute(item: unknown): item is DataModelAttribute;
 export interface DataModelField extends AstNode {
-    readonly $container: DataModel;
+    readonly $container: DataModel | Enum | FunctionDecl;
+    readonly $type: 'DataModelField';
     attributes: Array<DataModelFieldAttribute>;
-    name: string;
+    comments: Array<string>;
+    name: RegularID;
     type: DataModelFieldType;
 }
 export declare const DataModelField = "DataModelField";
 export declare function isDataModelField(item: unknown): item is DataModelField;
 export interface DataModelFieldAttribute extends AstNode {
-    readonly $container: DataModelField;
+    readonly $container: DataModelField | EnumField;
+    readonly $type: 'DataModelFieldAttribute';
     args: Array<AttributeArg>;
     decl: Reference<Attribute>;
 }
@@ -113,6 +129,7 @@ export declare const DataModelFieldAttribute = "DataModelFieldAttribute";
 export declare function isDataModelFieldAttribute(item: unknown): item is DataModelFieldAttribute;
 export interface DataModelFieldType extends AstNode {
     readonly $container: DataModelField;
+    readonly $type: 'DataModelFieldType';
     array: boolean;
     optional: boolean;
     reference?: Reference<TypeDeclaration>;
@@ -122,146 +139,225 @@ export declare const DataModelFieldType = "DataModelFieldType";
 export declare function isDataModelFieldType(item: unknown): item is DataModelFieldType;
 export interface DataSource extends AstNode {
     readonly $container: Model;
+    readonly $type: 'DataSource';
     fields: Array<DataSourceField>;
-    name: string;
+    name: RegularID;
 }
 export declare const DataSource = "DataSource";
 export declare function isDataSource(item: unknown): item is DataSource;
 export interface DataSourceField extends AstNode {
     readonly $container: DataSource;
-    name: string;
-    value: InvocationExpr | LiteralExpr;
+    readonly $type: 'DataSourceField';
+    name: RegularID;
+    value: ArrayExpr | InvocationExpr | LiteralExpr;
 }
 export declare const DataSourceField = "DataSourceField";
 export declare function isDataSourceField(item: unknown): item is DataSourceField;
 export interface Enum extends AstNode {
     readonly $container: Model;
+    readonly $type: 'Enum';
+    attributes: Array<DataModelAttribute>;
+    comments: Array<string>;
     fields: Array<EnumField>;
-    name: string;
+    name: RegularID;
 }
 export declare const Enum = "Enum";
 export declare function isEnum(item: unknown): item is Enum;
 export interface EnumField extends AstNode {
-    readonly $container: Enum;
-    name: string;
+    readonly $container: DataModel | Enum | FunctionDecl;
+    readonly $type: 'EnumField';
+    attributes: Array<DataModelFieldAttribute>;
+    comments: Array<string>;
+    name: RegularID;
 }
 export declare const EnumField = "EnumField";
 export declare function isEnumField(item: unknown): item is EnumField;
-export interface Function extends AstNode {
+export interface FieldInitializer extends AstNode {
+    readonly $container: ObjectExpr;
+    readonly $type: 'FieldInitializer';
+    name: RegularID;
+    value: Expression;
+}
+export declare const FieldInitializer = "FieldInitializer";
+export declare function isFieldInitializer(item: unknown): item is FieldInitializer;
+export interface FunctionDecl extends AstNode {
     readonly $container: Model;
+    readonly $type: 'FunctionDecl';
     expression?: Expression;
-    name: string;
+    name: RegularID;
     params: Array<FunctionParam>;
     returnType: FunctionParamType;
 }
-export declare const Function = "Function";
-export declare function isFunction(item: unknown): item is Function;
+export declare const FunctionDecl = "FunctionDecl";
+export declare function isFunctionDecl(item: unknown): item is FunctionDecl;
 export interface FunctionParam extends AstNode {
-    readonly $container: Function;
-    name: string;
+    readonly $container: DataModel | Enum | FunctionDecl;
+    readonly $type: 'FunctionParam';
+    name: RegularID;
+    optional: boolean;
     type: FunctionParamType;
 }
 export declare const FunctionParam = "FunctionParam";
 export declare function isFunctionParam(item: unknown): item is FunctionParam;
 export interface FunctionParamType extends AstNode {
-    readonly $container: Function | FunctionParam;
+    readonly $container: FunctionDecl | FunctionParam;
+    readonly $type: 'FunctionParamType';
     array: boolean;
     reference?: Reference<TypeDeclaration>;
     type?: ExpressionType;
 }
 export declare const FunctionParamType = "FunctionParamType";
 export declare function isFunctionParamType(item: unknown): item is FunctionParamType;
-export interface Generator extends AstNode {
+export interface GeneratorDecl extends AstNode {
     readonly $container: Model;
+    readonly $type: 'GeneratorDecl';
     fields: Array<GeneratorField>;
-    name: string;
+    name: RegularID;
 }
-export declare const Generator = "Generator";
-export declare function isGenerator(item: unknown): item is Generator;
+export declare const GeneratorDecl = "GeneratorDecl";
+export declare function isGeneratorDecl(item: unknown): item is GeneratorDecl;
 export interface GeneratorField extends AstNode {
-    readonly $container: Generator;
-    name: string;
+    readonly $container: GeneratorDecl;
+    readonly $type: 'GeneratorField';
+    name: RegularID;
     value: ArrayExpr | LiteralExpr;
 }
 export declare const GeneratorField = "GeneratorField";
 export declare function isGeneratorField(item: unknown): item is GeneratorField;
 export interface InvocationExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'InvocationExpr';
     args: Array<Argument>;
-    function: Reference<Function>;
+    function: Reference<FunctionDecl>;
 }
 export declare const InvocationExpr = "InvocationExpr";
 export declare function isInvocationExpr(item: unknown): item is InvocationExpr;
 export interface LiteralExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'LiteralExpr';
     value: boolean | number | string;
 }
 export declare const LiteralExpr = "LiteralExpr";
 export declare function isLiteralExpr(item: unknown): item is LiteralExpr;
 export interface MemberAccessExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'MemberAccessExpr';
     member: Reference<DataModelField>;
     operand: Expression;
 }
 export declare const MemberAccessExpr = "MemberAccessExpr";
 export declare function isMemberAccessExpr(item: unknown): item is MemberAccessExpr;
 export interface Model extends AstNode {
+    readonly $type: 'Model';
     declarations: Array<AbstractDeclaration>;
 }
 export declare const Model = "Model";
 export declare function isModel(item: unknown): item is Model;
 export interface NullExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'NullExpr';
     value: string;
 }
 export declare const NullExpr = "NullExpr";
 export declare function isNullExpr(item: unknown): item is NullExpr;
+export interface ObjectExpr extends AstNode {
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'ObjectExpr';
+    fields: Array<FieldInitializer>;
+}
+export declare const ObjectExpr = "ObjectExpr";
+export declare function isObjectExpr(item: unknown): item is ObjectExpr;
 export interface Plugin extends AstNode {
     readonly $container: Model;
+    readonly $type: 'Plugin';
     fields: Array<PluginField>;
-    name: string;
+    name: RegularID;
 }
 export declare const Plugin = "Plugin";
 export declare function isPlugin(item: unknown): item is Plugin;
 export interface PluginField extends AstNode {
     readonly $container: Plugin;
-    name: string;
-    value: ArrayExpr | LiteralExpr;
+    readonly $type: 'PluginField';
+    name: RegularID;
+    value: ArrayExpr | LiteralExpr | ObjectExpr;
 }
 export declare const PluginField = "PluginField";
 export declare function isPluginField(item: unknown): item is PluginField;
 export interface ReferenceArg extends AstNode {
     readonly $container: ReferenceExpr;
+    readonly $type: 'ReferenceArg';
     name: 'sort';
     value: 'Asc' | 'Desc';
 }
 export declare const ReferenceArg = "ReferenceArg";
 export declare function isReferenceArg(item: unknown): item is ReferenceArg;
 export interface ReferenceExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'ReferenceExpr';
     args: Array<ReferenceArg>;
     target: Reference<ReferenceTarget>;
 }
 export declare const ReferenceExpr = "ReferenceExpr";
 export declare function isReferenceExpr(item: unknown): item is ReferenceExpr;
 export interface ThisExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'ThisExpr';
     value: string;
 }
 export declare const ThisExpr = "ThisExpr";
 export declare function isThisExpr(item: unknown): item is ThisExpr;
 export interface UnaryExpr extends AstNode {
-    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | Function | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $container: Argument | ArrayExpr | AttributeArg | BinaryExpr | DataSourceField | FieldInitializer | FunctionDecl | GeneratorField | MemberAccessExpr | PluginField | UnaryExpr;
+    readonly $type: 'UnaryExpr';
     operand: Expression;
     operator: '!';
 }
 export declare const UnaryExpr = "UnaryExpr";
 export declare function isUnaryExpr(item: unknown): item is UnaryExpr;
-export type ZModelAstType = 'AbstractDeclaration' | 'Argument' | 'ArrayExpr' | 'Attribute' | 'AttributeArg' | 'AttributeAttribute' | 'AttributeParam' | 'AttributeParamType' | 'BinaryExpr' | 'DataModel' | 'DataModelAttribute' | 'DataModelField' | 'DataModelFieldAttribute' | 'DataModelFieldType' | 'DataSource' | 'DataSourceField' | 'Enum' | 'EnumField' | 'Expression' | 'Function' | 'FunctionParam' | 'FunctionParamType' | 'Generator' | 'GeneratorField' | 'InvocationExpr' | 'LiteralExpr' | 'MemberAccessExpr' | 'Model' | 'NullExpr' | 'Plugin' | 'PluginField' | 'ReferenceArg' | 'ReferenceExpr' | 'ReferenceTarget' | 'ThisExpr' | 'TypeDeclaration' | 'UnaryExpr';
-export declare class ZModelAstReflection implements AstReflection {
+export interface ZModelAstType {
+    AbstractDeclaration: AbstractDeclaration;
+    Argument: Argument;
+    ArrayExpr: ArrayExpr;
+    Attribute: Attribute;
+    AttributeArg: AttributeArg;
+    AttributeAttribute: AttributeAttribute;
+    AttributeParam: AttributeParam;
+    AttributeParamType: AttributeParamType;
+    BinaryExpr: BinaryExpr;
+    DataModel: DataModel;
+    DataModelAttribute: DataModelAttribute;
+    DataModelField: DataModelField;
+    DataModelFieldAttribute: DataModelFieldAttribute;
+    DataModelFieldType: DataModelFieldType;
+    DataSource: DataSource;
+    DataSourceField: DataSourceField;
+    Enum: Enum;
+    EnumField: EnumField;
+    Expression: Expression;
+    FieldInitializer: FieldInitializer;
+    FunctionDecl: FunctionDecl;
+    FunctionParam: FunctionParam;
+    FunctionParamType: FunctionParamType;
+    GeneratorDecl: GeneratorDecl;
+    GeneratorField: GeneratorField;
+    InvocationExpr: InvocationExpr;
+    LiteralExpr: LiteralExpr;
+    MemberAccessExpr: MemberAccessExpr;
+    Model: Model;
+    NullExpr: NullExpr;
+    ObjectExpr: ObjectExpr;
+    Plugin: Plugin;
+    PluginField: PluginField;
+    ReferenceArg: ReferenceArg;
+    ReferenceExpr: ReferenceExpr;
+    ReferenceTarget: ReferenceTarget;
+    ThisExpr: ThisExpr;
+    TypeDeclaration: TypeDeclaration;
+    UnaryExpr: UnaryExpr;
+}
+export declare class ZModelAstReflection extends AbstractAstReflection {
     getAllTypes(): string[];
-    isInstance(node: unknown, type: string): boolean;
-    isSubtype(subtype: string, supertype: string): boolean;
+    protected computeIsSubtype(subtype: string, supertype: string): boolean;
     getReferenceType(refInfo: ReferenceInfo): string;
     getTypeMetaData(type: string): TypeMetaData;
 }