brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/types/LongIntegerType.js

@@ -2,22 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LongIntegerType = void 0;
 const reflection_1 = require("../astUtils/reflection");
-class LongIntegerType {
-    isAssignableTo(targetType) {
-        return (reflection_1.isLongIntegerType(targetType) ||
-            reflection_1.isDynamicType(targetType));
+const BscType_1 = require("./BscType");
+const BscTypeKind_1 = require("./BscTypeKind");
+const helpers_1 = require("./helpers");
+const BuiltInInterfaceAdder_1 = require("./BuiltInInterfaceAdder");
+class LongIntegerType extends BscType_1.BscType {
+    constructor() {
+        super(...arguments);
+        this.kind = BscTypeKind_1.BscTypeKind.LongIntegerType;
+        this.isBuiltIn = true;
+        this.binaryOpPriorityLevel = 3;
     }
-    isConvertibleTo(targetType) {
-        if (reflection_1.isDynamicType(targetType) ||
-            reflection_1.isIntegerType(targetType) ||
-            reflection_1.isFloatType(targetType) ||
-            reflection_1.isDoubleType(targetType) ||
-            reflection_1.isLongIntegerType(targetType)) {
-            return true;
-        }
-        else {
-            return false;
-        }
+    isTypeCompatible(targetType, data) {
+        return ((0, reflection_1.isDynamicType)(targetType) ||
+            (0, reflection_1.isObjectType)(targetType) ||
+            (0, reflection_1.isNumberTypeLike)(targetType) ||
+            (0, helpers_1.isUnionTypeCompatible)(this, targetType, data) ||
+            (0, helpers_1.isEnumTypeCompatible)(this, targetType, data) ||
+            (0, helpers_1.isNativeInterfaceCompatibleNumber)(this, targetType, data));
     }
     toString() {
         return 'longinteger';
@@ -25,9 +27,11 @@ class LongIntegerType {
     toTypeString() {
         return this.toString();
     }
-    equals(targetType) {
-        return reflection_1.isLongIntegerType(targetType);
+    isEqual(targetType) {
+        return (0, reflection_1.isLongIntegerTypeLike)(targetType);
     }
 }
 exports.LongIntegerType = LongIntegerType;
+LongIntegerType.instance = new LongIntegerType();
+BuiltInInterfaceAdder_1.BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('longinteger', LongIntegerType.instance);
 //# sourceMappingURL=LongIntegerType.js.map

package/dist/types/LongIntegerType.js.map

@@ -1 +1 @@
-{"version":3,"file":"LongIntegerType.js","sourceRoot":"","sources":["../../src/types/LongIntegerType.ts"],"names":[],"mappings":";;;AAAA,uDAAoH;AAIpH,MAAa,eAAe;IACjB,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,8BAAiB,CAAC,UAAU,CAAC;YAC7B,0BAAa,CAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,UAAmB;QACtC,IACI,0BAAa,CAAC,UAAU,CAAC;YACzB,0BAAa,CAAC,UAAU,CAAC;YACzB,wBAAW,CAAC,UAAU,CAAC;YACvB,yBAAY,CAAC,UAAU,CAAC;YACxB,8BAAiB,CAAC,UAAU,CAAC,EAC/B;YACE,OAAO,IAAI,CAAC;SACf;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAEM,QAAQ;QACX,OAAO,aAAa,CAAC;IACzB,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,UAAmB;QAC7B,OAAO,8BAAiB,CAAC,UAAU,CAAC,CAAC;IACzC,CAAC;CACJ;AAjCD,0CAiCC"}
+{"version":3,"file":"LongIntegerType.js","sourceRoot":"","sources":["../../src/types/LongIntegerType.ts"],"names":[],"mappings":";;;AAAA,uDAA8G;AAC9G,uCAAoC;AACpC,+CAA4C;AAC5C,uCAA2G;AAC3G,mEAAgE;AAGhE,MAAa,eAAgB,SAAQ,iBAAO;IAA5C;;QACoB,SAAI,GAAG,yBAAW,CAAC,eAAe,CAAC;QAI5C,cAAS,GAAG,IAAI,CAAC;QAyBf,0BAAqB,GAAG,CAAC,CAAC;IACvC,CAAC;IAxBU,gBAAgB,CAAC,UAAmB,EAAE,IAA4B;QACrE,OAAO,CACH,IAAA,0BAAa,EAAC,UAAU,CAAC;YACzB,IAAA,yBAAY,EAAC,UAAU,CAAC;YACxB,IAAA,6BAAgB,EAAC,UAAU,CAAC;YAC5B,IAAA,+BAAqB,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC;YAC7C,IAAA,8BAAoB,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC;YAC5C,IAAA,2CAAiC,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAC5D,CAAC;IACN,CAAC;IAEM,QAAQ;QACX,OAAO,aAAa,CAAC;IACzB,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED,OAAO,CAAC,UAAmB;QACvB,OAAO,IAAA,kCAAqB,EAAC,UAAU,CAAC,CAAC;IAC7C,CAAC;;AA5BL,0CA+BC;AA5BiB,wBAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;AA8BnD,6CAAqB,CAAC,0BAA0B,CAAC,GAAG,CAAC,aAAa,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC"}

package/dist/types/LongIntegerType.spec.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
+const chai_config_spec_1 = require("../chai-config.spec");
 const DynamicType_1 = require("./DynamicType");
+const FloatType_1 = require("./FloatType");
 const LongIntegerType_1 = require("./LongIntegerType");
 describe('LongIntegerType', () => {
-    it('is equivalent to other long integer types', () => {
-        chai_1.expect(new LongIntegerType_1.LongIntegerType().isAssignableTo(new LongIntegerType_1.LongIntegerType())).to.be.true;
-        chai_1.expect(new LongIntegerType_1.LongIntegerType().isAssignableTo(new DynamicType_1.DynamicType())).to.be.true;
+    it('is equal to other longinteger types', () => {
+        (0, chai_config_spec_1.expect)(new LongIntegerType_1.LongIntegerType().isEqual(new LongIntegerType_1.LongIntegerType())).to.be.true;
+        (0, chai_config_spec_1.expect)(new LongIntegerType_1.LongIntegerType().isEqual(new DynamicType_1.DynamicType())).to.be.false;
+    });
+    it('is compatible with to other integer types', () => {
+        (0, chai_config_spec_1.expect)(new LongIntegerType_1.LongIntegerType().isTypeCompatible(new LongIntegerType_1.LongIntegerType())).to.be.true;
+        (0, chai_config_spec_1.expect)(new LongIntegerType_1.LongIntegerType().isTypeCompatible(new FloatType_1.FloatType())).to.be.true;
+        (0, chai_config_spec_1.expect)(new LongIntegerType_1.LongIntegerType().isTypeCompatible(new DynamicType_1.DynamicType())).to.be.true;
     });
 });
 //# sourceMappingURL=LongIntegerType.spec.js.map

package/dist/types/LongIntegerType.spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"LongIntegerType.spec.js","sourceRoot":"","sources":["../../src/types/LongIntegerType.spec.ts"],"names":[],"mappings":";;AAAA,+BAA8B;AAE9B,+CAA4C;AAC5C,uDAAoD;AAEpD,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACjD,aAAM,CAAC,IAAI,iCAAe,EAAE,CAAC,cAAc,CAAC,IAAI,iCAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QAC/E,aAAM,CAAC,IAAI,iCAAe,EAAE,CAAC,cAAc,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;IAC/E,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}
+{"version":3,"file":"LongIntegerType.spec.js","sourceRoot":"","sources":["../../src/types/LongIntegerType.spec.ts"],"names":[],"mappings":";;AAAA,0DAA6C;AAE7C,+CAA4C;AAC5C,2CAAwC;AACxC,uDAAoD;AAEpD,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC3C,IAAA,yBAAM,EAAC,IAAI,iCAAe,EAAE,CAAC,OAAO,CAAC,IAAI,iCAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QACxE,IAAA,yBAAM,EAAC,IAAI,iCAAe,EAAE,CAAC,OAAO,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACjD,IAAA,yBAAM,EAAC,IAAI,iCAAe,EAAE,CAAC,gBAAgB,CAAC,IAAI,iCAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QACjF,IAAA,yBAAM,EAAC,IAAI,iCAAe,EAAE,CAAC,gBAAgB,CAAC,IAAI,qBAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QAC3E,IAAA,yBAAM,EAAC,IAAI,iCAAe,EAAE,CAAC,gBAAgB,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;IACjF,CAAC,CAAC,CAAC;AAEP,CAAC,CAAC,CAAC"}

package/dist/types/NamespaceType.d.ts

@@ -0,0 +1,12 @@
+import type { GetTypeOptions, TypeCompatibilityData } from '../interfaces';
+import { BscType } from './BscType';
+import { BscTypeKind } from './BscTypeKind';
+export declare class NamespaceType extends BscType {
+    name: string;
+    constructor(name: string);
+    readonly kind = BscTypeKind.NamespaceType;
+    toString(): string;
+    isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData): boolean;
+    getMemberType(name: string, options: GetTypeOptions): BscType;
+    isEqual(targetType: BscType): boolean;
+}

package/dist/types/NamespaceType.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespaceType = void 0;
+const reflection_1 = require("../astUtils/reflection");
+const BscType_1 = require("./BscType");
+const BscTypeKind_1 = require("./BscTypeKind");
+class NamespaceType extends BscType_1.BscType {
+    constructor(name) {
+        super(name);
+        this.name = name;
+        this.kind = BscTypeKind_1.BscTypeKind.NamespaceType;
+    }
+    toString() {
+        return this.name;
+    }
+    isTypeCompatible(targetType, data) {
+        return this.isEqual(targetType);
+    }
+    getMemberType(name, options) {
+        const fullName = this.toString() + '.' + name;
+        return super.getMemberType(name, Object.assign(Object.assign({}, options), { fullName: fullName, tableProvider: () => this.memberTable }));
+    }
+    isEqual(targetType) {
+        return (0, reflection_1.isNamespaceType)(targetType) && targetType.name === this.name;
+    }
+}
+exports.NamespaceType = NamespaceType;
+//# sourceMappingURL=NamespaceType.js.map

package/dist/types/NamespaceType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NamespaceType.js","sourceRoot":"","sources":["../../src/types/NamespaceType.ts"],"names":[],"mappings":";;;AAAA,uDAAyD;AAEzD,uCAAoC;AACpC,+CAA4C;AAE5C,MAAa,aAAc,SAAQ,iBAAO;IAEtC,YAAmB,IAAY;QAC3B,KAAK,CAAC,IAAI,CAAC,CAAC;QADG,SAAI,GAAJ,IAAI,CAAQ;QAIf,SAAI,GAAG,yBAAW,CAAC,aAAa,CAAC;IAFjD,CAAC;IAIM,QAAQ;QACX,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAEM,gBAAgB,CAAC,UAAmB,EAAE,IAA4B;QACrE,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IACpC,CAAC;IAGD,aAAa,CAAC,IAAY,EAAE,OAAuB;QAC/C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,GAAG,IAAI,CAAC;QAC9C,OAAO,KAAK,CAAC,aAAa,CAAC,IAAI,kCAAO,OAAO,KAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,IAAG,CAAC;IAChH,CAAC;IAED,OAAO,CAAC,UAAmB;QACvB,OAAO,IAAA,4BAAe,EAAC,UAAU,CAAC,IAAI,UAAU,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC;IACxE,CAAC;CAEJ;AA1BD,sCA0BC"}

package/dist/types/ObjectType.d.ts

@@ -1,8 +1,15 @@
-import type { BscType } from './BscType';
-export declare class ObjectType implements BscType {
-    isAssignableTo(targetType: BscType): any;
-    isConvertibleTo(targetType: BscType): any;
+import type { GetTypeOptions, TypeCompatibilityData } from '../interfaces';
+import { BscType } from './BscType';
+import { BscTypeKind } from './BscTypeKind';
+import { DynamicType } from './DynamicType';
+export declare class ObjectType extends BscType {
+    readonly kind = BscTypeKind.ObjectType;
+    isBuiltIn: boolean;
+    isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData): boolean;
+    static instance: ObjectType;
     toString(): string;
     toTypeString(): string;
-    equals(targetType: BscType): boolean;
+    getMemberType(name: string, options: GetTypeOptions): DynamicType;
+    isEqual(otherType: BscType): boolean;
+    get returnType(): DynamicType;
 }

package/dist/types/ObjectType.js

@@ -2,13 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectType = void 0;
 const reflection_1 = require("../astUtils/reflection");
-class ObjectType {
-    isAssignableTo(targetType) {
-        return (reflection_1.isObjectType(targetType) ||
-            reflection_1.isDynamicType(targetType));
+const BscType_1 = require("./BscType");
+const BscTypeKind_1 = require("./BscTypeKind");
+const BuiltInInterfaceAdder_1 = require("./BuiltInInterfaceAdder");
+const DynamicType_1 = require("./DynamicType");
+class ObjectType extends BscType_1.BscType {
+    constructor() {
+        super(...arguments);
+        this.kind = BscTypeKind_1.BscTypeKind.ObjectType;
+        this.isBuiltIn = true;
     }
-    isConvertibleTo(targetType) {
-        return this.isAssignableTo(targetType);
+    isTypeCompatible(targetType, data) {
+        //Brightscript allows anything passed "as object", so as long as a type is provided, this is true
+        return !!targetType;
     }
     toString() {
         return 'object';
@@ -16,9 +22,20 @@ class ObjectType {
     toTypeString() {
         return this.toString();
     }
-    equals(targetType) {
-        return reflection_1.isObjectType(targetType) && this.isAssignableTo(targetType);
+    getMemberType(name, options) {
+        if (options.ignoreDefaultDynamicMembers) {
+            return undefined;
+        }
+        return DynamicType_1.DynamicType.instance;
+    }
+    isEqual(otherType) {
+        return (0, reflection_1.isObjectType)(otherType) && this.checkCompatibilityBasedOnMembers(otherType, 1 /* SymbolTypeFlag.runtime */);
+    }
+    get returnType() {
+        return DynamicType_1.DynamicType.instance;
     }
 }
 exports.ObjectType = ObjectType;
+ObjectType.instance = new ObjectType();
+BuiltInInterfaceAdder_1.BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('object', ObjectType.instance);
 //# sourceMappingURL=ObjectType.js.map

package/dist/types/ObjectType.js.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectType.js","sourceRoot":"","sources":["../../src/types/ObjectType.ts"],"names":[],"mappings":";;;AAAA,uDAAqE;AAGrE,MAAa,UAAU;IACZ,cAAc,CAAC,UAAmB;QACrC,OAAO,CACH,yBAAY,CAAC,UAAU,CAAC;YACxB,0BAAa,CAAC,UAAU,CAAC,CAC5B,CAAC;IACN,CAAC;IAEM,eAAe,CAAC,UAAmB;QACtC,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAEM,QAAQ;QACX,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEM,MAAM,CAAC,UAAmB;QAC7B,OAAO,yBAAY,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IACvE,CAAC;CACJ;AAvBD,gCAuBC"}
+{"version":3,"file":"ObjectType.js","sourceRoot":"","sources":["../../src/types/ObjectType.ts"],"names":[],"mappings":";;;AACA,uDAAsD;AAEtD,uCAAoC;AACpC,+CAA4C;AAC5C,mEAAgE;AAChE,+CAA4C;AAE5C,MAAa,UAAW,SAAQ,iBAAO;IAAvC;;QAEoB,SAAI,GAAG,yBAAW,CAAC,UAAU,CAAC;QAEvC,cAAS,GAAG,IAAI,CAAC;IA+B5B,CAAC;IA7BU,gBAAgB,CAAC,UAAmB,EAAE,IAA4B;QACrE,iGAAiG;QACjG,OAAO,CAAC,CAAC,UAAU,CAAC;IACxB,CAAC;IAIM,QAAQ;QACX,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEM,YAAY;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED,aAAa,CAAC,IAAY,EAAE,OAAuB;QAC/C,IAAI,OAAO,CAAC,2BAA2B,EAAE;YACrC,OAAO,SAAS,CAAC;SACpB;QACD,OAAO,yBAAW,CAAC,QAAQ,CAAC;IAChC,CAAC;IAED,OAAO,CAAC,SAAkB;QACtB,OAAO,IAAA,yBAAY,EAAC,SAAS,CAAC,IAAI,IAAI,CAAC,gCAAgC,CAAC,SAAS,iCAAyB,CAAC;IAC/G,CAAC;IAED,IAAI,UAAU;QACV,OAAO,yBAAW,CAAC,QAAQ,CAAC;IAChC,CAAC;;AAlCL,gCAmCC;AAxBiB,mBAAQ,GAAG,IAAI,UAAU,EAAE,CAAC;AA2B9C,6CAAqB,CAAC,0BAA0B,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC"}

package/dist/types/ObjectType.spec.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
+const chai_config_spec_1 = require("../chai-config.spec");
 const DynamicType_1 = require("./DynamicType");
 const ObjectType_1 = require("./ObjectType");
 describe('ObjectType', () => {
     it('is equivalent to other object types', () => {
-        chai_1.expect(new ObjectType_1.ObjectType().isAssignableTo(new ObjectType_1.ObjectType())).to.be.true;
-        chai_1.expect(new ObjectType_1.ObjectType().isAssignableTo(new DynamicType_1.DynamicType())).to.be.true;
+        (0, chai_config_spec_1.expect)(new ObjectType_1.ObjectType().isTypeCompatible(new ObjectType_1.ObjectType())).to.be.true;
+        (0, chai_config_spec_1.expect)(new ObjectType_1.ObjectType().isTypeCompatible(new DynamicType_1.DynamicType())).to.be.true;
     });
 });
 //# sourceMappingURL=ObjectType.spec.js.map

package/dist/types/ObjectType.spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectType.spec.js","sourceRoot":"","sources":["../../src/types/ObjectType.spec.ts"],"names":[],"mappings":";;AAAA,+BAA8B;AAE9B,+CAA4C;AAC5C,6CAA0C;AAE1C,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;IACxB,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC3C,aAAM,CAAC,IAAI,uBAAU,EAAE,CAAC,cAAc,CAAC,IAAI,uBAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QACrE,aAAM,CAAC,IAAI,uBAAU,EAAE,CAAC,cAAc,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;IAC1E,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}
+{"version":3,"file":"ObjectType.spec.js","sourceRoot":"","sources":["../../src/types/ObjectType.spec.ts"],"names":[],"mappings":";;AAAA,0DAA6C;AAE7C,+CAA4C;AAC5C,6CAA0C;AAE1C,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;IACxB,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC3C,IAAA,yBAAM,EAAC,IAAI,uBAAU,EAAE,CAAC,gBAAgB,CAAC,IAAI,uBAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;QACvE,IAAA,yBAAM,EAAC,IAAI,uBAAU,EAAE,CAAC,gBAAgB,CAAC,IAAI,yBAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC;IAC5E,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

package/dist/types/ReferenceType.d.ts

@@ -0,0 +1,123 @@
+import type { TypeCircularReferenceInfo } from '../interfaces';
+import type { SymbolTableProvider, SymbolTypeGetterProvider } from '../SymbolTable';
+import type { SymbolTypeFlag } from '../SymbolTypeFlag';
+import { BscType } from './BscType';
+import { BscTypeKind } from './BscTypeKind';
+import type { Token } from '../lexer/Token';
+export declare type AnyReferenceType = ReferenceType | TypePropertyReferenceType | BinaryOperatorReferenceType | ArrayDefaultTypeReferenceType;
+export declare function referenceTypeFactory(memberKey: string, fullName: any, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider): ReferenceType;
+export declare class ReferenceType extends BscType {
+    memberKey: string;
+    fullName: any;
+    flags: SymbolTypeFlag;
+    tableProvider: SymbolTypeGetterProvider;
+    /**
+     * ReferenceTypes are used when the actual type may be resolved later from a Symbol table
+     * @param memberKey which key do we use to look up this type in the given table?
+     * @param fullName the full/display name for this type
+     * @param flags is this type available at typetime, runtime, etc.
+     * @param tableProvider function that returns a SymbolTable that we use for the lookup.
+     */
+    constructor(memberKey: string, fullName: any, flags: SymbolTypeFlag, tableProvider: SymbolTypeGetterProvider);
+    readonly kind = BscTypeKind.ReferenceType;
+    getTarget(): BscType;
+    /**
+     * Resolves the type based on the original name and the table provider
+     */
+    private resolve;
+    get __reflection(): {
+        name: string;
+    };
+    makeMemberFullName(memberName: string): string;
+    getCircularReferenceInfo(stopAtTypes?: ReferenceType[]): TypeCircularReferenceInfo;
+    private circRefCount;
+    private referenceChain;
+    private propertyTypeReference;
+    private memberTypeReferences;
+    private callFuncMemberTypeReferences;
+    private futureMemberTableProvider;
+    private futureCallFuncMemberTableProvider;
+}
+/**
+ * Use this class for when you need to reference a property of a BscType, and that property is also a BscType,
+ * Especially when the instance with the property may not have been instantiated/discovered yet
+ *
+ * For Example, FunctionType.returnType --- if the FunctionExpression has not been walked yet, it will be a ReferenceType
+ * if we just access .returnType on a ReferenceType that doesn't have access to an actual FunctionType yet, .returnType will be undefined
+ * So when we use this class, it maintains that reference to a potential ReferenceType, and this class will change from
+ * returning undefined to the ACTUAL .returnType when the ReferenceType can be resolved.
+ *
+ * This is really cool. It's like programming with time-travel.
+ */
+export declare class TypePropertyReferenceType extends BscType {
+    outerType: BscType;
+    propertyName: string;
+    constructor(outerType: BscType, propertyName: string);
+    getTarget(): BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Use this class for when there is a binary operator and either the left hand side and/or the right hand side
+ * are ReferenceTypes
+ */
+export declare class BinaryOperatorReferenceType extends BscType {
+    leftType: BscType;
+    operator: Token;
+    rightType: BscType;
+    cachedType: BscType;
+    constructor(leftType: BscType, operator: Token, rightType: BscType, binaryOpResolver: (lType: BscType, operator: Token, rType: BscType) => BscType);
+    getTarget: () => BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Use this class for when there is a presumable array type that is a referenceType
+ */
+export declare class ArrayDefaultTypeReferenceType extends BscType {
+    objType: BscType;
+    constructor(objType: BscType);
+    getTarget: () => BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Used for when a Param's initial value is unresolved
+ * Generally, this will be resolved later *except* for Enum
+ * Enum Types will have an initial value of an EnumMemberType, but the param
+ * should be an EnumType
+ */
+export declare class ParamTypeFromValueReferenceType extends BscType {
+    objType: BscType;
+    cachedType: BscType;
+    constructor(objType: BscType);
+}
+/**
+ * Used when an IntersectionType has at least one member that may have default dynamic members.
+ * If the inner type is not resolvable, this type will resolve to the given type instead.
+ * @example
+ * ```brighterscript
+ *   interface HasAge
+ *       age as integer
+ *   end interface
+ *
+ *   type foo = HasAge and roAssociativeArray
+ *
+ *   sub useFoo(f as foo)
+ *       print f.age ' f.age is an integer
+ *       print f.doesExist("key") ' will result in a boolean, from roAssociativeArray
+ *       print f.someKey ' no idea - so this is dynamic, and will not cause a validation error
+ *   end sub
+ * ```
+ */
+export declare class ReferenceTypeWithDefault extends BscType {
+    baseType: BscType;
+    defaultType: BscType;
+    constructor(baseType: BscType, defaultType: BscType);
+    getTarget(): BscType;
+    tableProvider: SymbolTableProvider;
+}
+/**
+ * Gives an array of all the symbol names that need to be resolved to make the given reference type be resolved
+ */
+export declare function getAllRequiredSymbolNames(refType: BscType, namespaceLower?: string): Array<{
+    name: string;
+    namespacedName?: string;
+}>;