@quenty/tie 10.27.1 → 10.28.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [10.28.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/tie@10.27.1...@quenty/tie@10.28.0) (2026-01-06)
+
+
+### Bug Fixes
+
+* Add more typing ([f32615e](https://github.com/Quenty/NevermoreEngine/commit/f32615ec9d846a1a4392a3b21a0f594e8d420b44))
+* Add some strict typing to Tie ([cbdb842](https://github.com/Quenty/NevermoreEngine/commit/cbdb842d6c2a57cf5c1cabab90505cbfec62037b))
+
+
+
+
+
 ## [10.27.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/tie@10.27.0...@quenty/tie@10.27.1) (2026-01-05)
 
 **Note:** Version bump only for package @quenty/tie

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/tie",
-  "version": "10.27.1",
+  "version": "10.28.0",
   "description": "Tie allows interfaces to be defined between Lua OOP and Roblox objects.",
   "keywords": [
     "Roblox",
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5232cd2c58ca0dcdf591dd8ae78995211da2f3e2"
+  "gitHead": "540aa2a77acbb6c9c5967fe4417400a903df2c2c"
 }

package/src/Shared/Members/Properties/TiePropertyDefinition.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	@class TiePropertyDefinition
 ]=]
@@ -9,16 +9,31 @@ local TieMemberDefinition = require("TieMemberDefinition")
 local TiePropertyImplementation = require("TiePropertyImplementation")
 local TiePropertyInterface = require("TiePropertyInterface")
 local TieRealmUtils = require("TieRealmUtils")
+local TieRealms = require("TieRealms")
 
 local TiePropertyDefinition = setmetatable({}, TieMemberDefinition)
 TiePropertyDefinition.ClassName = "TiePropertyDefinition"
 TiePropertyDefinition.__index = TiePropertyDefinition
 
-function TiePropertyDefinition.new(tieDefinition, propertyName: string, defaultValue: any, memberTieRealm)
+export type TiePropertyDefinition =
+	typeof(setmetatable(
+		{} :: {
+			_defaultValue: any,
+		},
+		{} :: typeof({ __index = TieMemberDefinition })
+	))
+	& TieMemberDefinition.TieMemberDefinition
+
+function TiePropertyDefinition.new(
+	tieDefinition: any,
+	propertyName: string,
+	defaultValue: any,
+	memberTieRealm: TieRealms.TieRealm
+): TiePropertyDefinition
 	assert(TieRealmUtils.isTieRealm(memberTieRealm), "Bad memberTieRealm")
 
-	local self =
-		setmetatable(TieMemberDefinition.new(tieDefinition, propertyName, memberTieRealm), TiePropertyDefinition)
+	local self: TiePropertyDefinition =
+		setmetatable(TieMemberDefinition.new(tieDefinition, propertyName, memberTieRealm) :: any, TiePropertyDefinition)
 
 	self._defaultValue = defaultValue
 
@@ -29,7 +44,7 @@ function TiePropertyDefinition:GetDefaultValue()
 	return self._defaultValue
 end
 
-function TiePropertyDefinition:IsRequiredForImplementation(currentRealm): boolean
+function TiePropertyDefinition:IsRequiredForImplementation(currentRealm: TieRealms.TieRealm): boolean
 	-- Override
 	if getmetatable(TiePropertyDefinition).IsRequiredForImplementation(self, currentRealm) then
 		if self:GetDefaultValue() ~= nil then
@@ -42,14 +57,14 @@ function TiePropertyDefinition:IsRequiredForImplementation(currentRealm): boolea
 	return false
 end
 
-function TiePropertyDefinition:Implement(implParent: Instance, initialValue, _actualSelf, tieRealm)
+function TiePropertyDefinition:Implement(implParent: Instance, initialValue, _actualSelf, tieRealm: TieRealms.TieRealm)
 	assert(typeof(implParent) == "Instance", "Bad implParent")
 	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
 
 	return TiePropertyImplementation.new(self, implParent, initialValue, tieRealm)
 end
 
-function TiePropertyDefinition:GetInterface(implParent: Instance, _actualSelf, tieRealm)
+function TiePropertyDefinition:GetInterface(implParent: Instance, _actualSelf, tieRealm: TieRealms.TieRealm)
 	assert(typeof(implParent) == "Instance", "Bad implParent")
 	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
 

package/src/Shared/Members/Properties/TiePropertyImplementation.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	@class TiePropertyImplementation
 ]=]
@@ -18,8 +18,18 @@ local TiePropertyImplementation = setmetatable({}, BaseObject)
 TiePropertyImplementation.ClassName = "TiePropertyImplementation"
 TiePropertyImplementation.__index = TiePropertyImplementation
 
-function TiePropertyImplementation.new(memberDefinition, folder: Folder, initialValue, _actualSelf)
-	local self = setmetatable(BaseObject.new(), TiePropertyImplementation)
+export type TiePropertyImplementation =
+	typeof(setmetatable(
+		{} :: {
+			_folder: Instance,
+			_memberDefinition: any,
+		},
+		{} :: typeof({ __index = TiePropertyImplementation })
+	))
+	& BaseObject.BaseObject
+
+function TiePropertyImplementation.new(memberDefinition, folder: Instance, initialValue, _actualSelf)
+	local self = setmetatable(BaseObject.new() :: any, TiePropertyImplementation)
 
 	self._memberDefinition = assert(memberDefinition, "No memberDefinition")
 	self._folder = assert(folder, "No folder")
@@ -51,8 +61,8 @@ function TiePropertyImplementation.new(memberDefinition, folder: Folder, initial
 	return self
 end
 
-function TiePropertyImplementation:SetImplementation(implementation)
-	self._maid._current = nil
+function TiePropertyImplementation.SetImplementation(self: TiePropertyImplementation, implementation)
+	self._maid._current = nil :: Maid.Maid?
 
 	local maid = Maid.new()
 
@@ -66,7 +76,11 @@ function TiePropertyImplementation:SetImplementation(implementation)
 	self._maid._current = maid
 end
 
-function TiePropertyImplementation:_updateImplementation(maid, implementation)
+function TiePropertyImplementation._updateImplementation(
+	self: TiePropertyImplementation,
+	maid: Maid.Maid,
+	implementation
+)
 	if ValueObject.isValueObject(implementation) then
 		local checkType = implementation:GetCheckType()
 
@@ -80,7 +94,7 @@ function TiePropertyImplementation:_updateImplementation(maid, implementation)
 	end
 
 	if type(implementation) == "table" and implementation.Changed then
-		local copy = self:_changeToClassIfNeeded("BindableFunction", implementation)
+		local copy: BindableFunction = self:_changeToClassIfNeeded("BindableFunction") :: any
 		copy.OnInvoke = function()
 			return TieUtils.encode(implementation)
 		end
@@ -89,14 +103,14 @@ function TiePropertyImplementation:_updateImplementation(maid, implementation)
 	end
 
 	if typeof(implementation) == "Instance" and implementation:IsA("ValueBase") then
-		local resultingType = ValueBaseUtils.getValueBaseType(implementation.ClassName)
+		local resultingType = ValueBaseUtils.getValueBaseType(implementation.ClassName :: any)
 		if resultingType and AttributeUtils.isValidAttributeType(resultingType) and resultingType ~= "nil" then
 			self:_removeClassIfNeeded()
 
 			local attributeValue = AttributeValue.new(self._folder, self._memberDefinition:GetMemberName())
 			self:_syncMember(maid, attributeValue, implementation)
 		else
-			local copy = self:_changeToClassIfNeeded(implementation.ClassName, implementation)
+			local copy = self:_changeToClassIfNeeded(implementation.ClassName)
 			self:_syncMember(maid, copy, implementation)
 			copy.Parent = self._folder
 		end
@@ -121,23 +135,28 @@ function TiePropertyImplementation:_updateImplementation(maid, implementation)
 		)
 	end
 
-	local copy = self:_changeToClassIfNeeded(className, implementation)
-	copy.Value = implementation
+	local copy = self:_changeToClassIfNeeded(className);
+	(copy :: any).Value = implementation
 	copy.Parent = self._folder
 end
 
-function TiePropertyImplementation:_changeToClassIfNeeded(className)
+function TiePropertyImplementation._changeToClassIfNeeded(self: TiePropertyImplementation, className: string): Instance
 	return TiePropertyImplementationUtils.changeToClassIfNeeded(self._memberDefinition, self._folder, className)
 end
 
-function TiePropertyImplementation:_removeClassIfNeeded()
+function TiePropertyImplementation._removeClassIfNeeded(self: TiePropertyImplementation)
 	local implementation = self._folder:FindFirstChild(self._memberDefinition:GetMemberName())
 	if implementation then
 		implementation:Destroy()
 	end
 end
 
-function TiePropertyImplementation:_syncMember(maid, copy, implementation)
+function TiePropertyImplementation._syncMember(
+	_self: TiePropertyImplementation,
+	maid: Maid.Maid,
+	copy: any,
+	implementation
+)
 	copy.Value = implementation.Value
 
 	maid:GiveTask(implementation.Changed:Connect(function()

package/src/Shared/Members/Properties/TiePropertyImplementationUtils.lua

@@ -1,11 +1,15 @@
---!nonstrict
+--!strict
 --[=[
 	@class TiePropertyImplementationUtils
 ]=]
 
 local TiePropertyImplementationUtils = {}
 
-function TiePropertyImplementationUtils.changeToClassIfNeeded(memberDefinition, folder: Folder, className: string)
+function TiePropertyImplementationUtils.changeToClassIfNeeded(
+	memberDefinition,
+	folder: Instance,
+	className: string
+): Instance
 	local memberName = memberDefinition:GetMemberName()
 	folder:SetAttribute(memberName, nil)
 

package/src/Shared/Members/Properties/TiePropertyInterface.lua

@@ -17,6 +17,7 @@ local String = require("String")
 local Symbol = require("Symbol")
 local TieMemberInterface = require("TieMemberInterface")
 local TiePropertyImplementationUtils = require("TiePropertyImplementationUtils")
+local TieRealms = require("TieRealms")
 local TieUtils = require("TieUtils")
 local ValueBaseUtils = require("ValueBaseUtils")
 
@@ -26,7 +27,12 @@ local TiePropertyInterface = setmetatable({}, TieMemberInterface)
 TiePropertyInterface.ClassName = "TiePropertyInterface"
 TiePropertyInterface.__index = TiePropertyInterface
 
-function TiePropertyInterface.new(implParent, adornee: Instance, memberDefinition, interfaceTieRealm)
+function TiePropertyInterface.new(
+	implParent: Instance,
+	adornee: Instance,
+	memberDefinition,
+	interfaceTieRealm: TieRealms.TieRealm
+)
 	local self = setmetatable(
 		TieMemberInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm),
 		TiePropertyInterface

package/src/Shared/Members/TieMemberDefinition.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Base class for a member definition/declaration.
 
@@ -14,10 +14,23 @@ local TieMemberDefinition = {}
 TieMemberDefinition.ClassName = "TieMemberDefinition"
 TieMemberDefinition.__index = TieMemberDefinition
 
-function TieMemberDefinition.new(tieDefinition, memberName: string, memberTieRealm)
+export type TieMemberDefinition = typeof(setmetatable(
+	{} :: {
+		_tieDefinition: any,
+		_memberName: string,
+		_memberTieRealm: TieRealms.TieRealm,
+	},
+	{} :: typeof({ __index = TieMemberDefinition })
+))
+
+function TieMemberDefinition.new(
+	tieDefinition: any,
+	memberName: string,
+	memberTieRealm: TieRealms.TieRealm
+): TieMemberDefinition
 	assert(TieRealmUtils.isTieRealm(memberTieRealm), "Bad memberTieRealm")
 
-	local self = setmetatable({}, TieMemberDefinition)
+	local self: TieMemberDefinition = setmetatable({} :: any, TieMemberDefinition)
 
 	self._tieDefinition = assert(tieDefinition, "No tieDefinition")
 	self._memberName = assert(memberName, "Bad memberName")
@@ -38,7 +51,7 @@ function TieMemberDefinition:GetFriendlyName(): string
 	return string.format("%s.%s", self._tieDefinition:GetName(), self._memberName)
 end
 
-function TieMemberDefinition:IsRequiredForInterface(currentRealm): boolean
+function TieMemberDefinition:IsRequiredForInterface(currentRealm: TieRealms.TieRealm): boolean
 	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
 
 	if self._memberTieRealm == TieRealms.SHARED then
@@ -51,7 +64,7 @@ function TieMemberDefinition:IsRequiredForInterface(currentRealm): boolean
 	end
 end
 
-function TieMemberDefinition:IsAllowedOnInterface(currentRealm): boolean
+function TieMemberDefinition:IsAllowedOnInterface(currentRealm: TieRealms.TieRealm): boolean
 	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
 
 	if self._memberTieRealm == TieRealms.SHARED then
@@ -64,7 +77,7 @@ function TieMemberDefinition:IsAllowedOnInterface(currentRealm): boolean
 	end
 end
 
-function TieMemberDefinition:IsRequiredForImplementation(currentRealm): boolean
+function TieMemberDefinition:IsRequiredForImplementation(currentRealm: TieRealms.TieRealm): boolean
 	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
 
 	if currentRealm == TieRealms.SHARED then
@@ -77,7 +90,7 @@ function TieMemberDefinition:IsRequiredForImplementation(currentRealm): boolean
 	end
 end
 
-function TieMemberDefinition:IsAllowedForImplementation(currentRealm): boolean
+function TieMemberDefinition:IsAllowedForImplementation(currentRealm: TieRealms.TieRealm): boolean
 	assert(TieRealmUtils.isTieRealm(currentRealm), "Bad currentRealm")
 
 	if self._memberTieRealm == TieRealms.SHARED then
@@ -90,7 +103,7 @@ function TieMemberDefinition:IsAllowedForImplementation(currentRealm): boolean
 	end
 end
 
-function TieMemberDefinition:GetMemberTieRealm()
+function TieMemberDefinition:GetMemberTieRealm(): TieRealms.TieRealm
 	return self._memberTieRealm
 end
 

package/src/Shared/Members/TieMemberInterface.lua

@@ -9,12 +9,18 @@ local Rx = require("Rx")
 local RxBrioUtils = require("RxBrioUtils")
 local RxInstanceUtils = require("RxInstanceUtils")
 local TieRealmUtils = require("TieRealmUtils")
+local TieRealms = require("TieRealms")
 
 local TieMemberInterface = {}
 TieMemberInterface.ClassName = "TieMemberInterface"
 TieMemberInterface.__index = TieMemberInterface
 
-function TieMemberInterface.new(implParent, adornee, memberDefinition, interfaceTieRealm)
+function TieMemberInterface.new(
+	implParent: Instance?,
+	adornee: Instance?,
+	memberDefinition,
+	interfaceTieRealm: TieRealms.TieRealm
+)
 	assert(TieRealmUtils.isTieRealm(interfaceTieRealm), "Bad interfaceTieRealm")
 
 	local self = setmetatable({}, TieMemberInterface)

package/src/Shared/Realms/TieRealmUtils.lua

@@ -31,7 +31,7 @@ end
 
 	@return TieRealm
 ]=]
-function TieRealmUtils.inferTieRealm(): "server" | "client"
+function TieRealmUtils.inferTieRealm(): TieRealms.TieRealm
 	if RunService:IsServer() then
 		return TieRealms.SERVER
 	elseif RunService:IsClient() then

package/src/Shared/Realms/TieRealms.lua

@@ -12,9 +12,9 @@ local Table = require("Table")
 export type TieRealm = "shared" | "client" | "server"
 
 export type TieRealms = {
-	SHARED: "shared",
-	CLIENT: "client",
-	SERVER: "server",
+	SHARED: TieRealm,
+	CLIENT: TieRealm,
+	SERVER: TieRealm,
 }
 
 return Table.readonly({

package/src/Shared/TieDefinition.lua

@@ -1,4 +1,4 @@
---!nonstrict
+--!strict
 --[=[
 	Constructs a new interface declaration which allows for interface usage
 	between both Roblox API users and OOP users, as well as without accessing a
@@ -48,6 +48,7 @@ local require = require(script.Parent.loader).load(script)
 local Brio = require("Brio")
 local Maid = require("Maid")
 local Observable = require("Observable")
+local Promise = require("Promise")
 local Rx = require("Rx")
 local RxBrioUtils = require("RxBrioUtils")
 local RxCollectionServiceUtils = require("RxCollectionServiceUtils")
@@ -67,19 +68,55 @@ local ValueObject = require("ValueObject")
 
 local UNSET_VALUE = Symbol.named("unsetValue")
 
+local IMPL_CLIENT_SET = table.freeze({
+	["Configuration"] = true,
+})
+
+local IMPL_SERVER_SET = table.freeze({
+	["Camera"] = true,
+})
+
+local IMPL_SHARED_SET = table.freeze({
+	["Camera"] = true,
+	["Configuration"] = true,
+})
+
 export type TieRealm = TieRealms.TieRealm
 
 local TieDefinition = {}
 TieDefinition.ClassName = "TieDefinition"
 TieDefinition.__index = TieDefinition
 
+export type TieDefinitionType = "method" | "signal" | "property"
+export type TieDefinitionTypes = {
+	METHOD: TieDefinitionType,
+	SIGNAL: TieDefinitionType,
+	PROPERTY: TieDefinitionType,
+}
 TieDefinition.Types = Table.readonly({
 	METHOD = Symbol.named("method"),
 	SIGNAL = Symbol.named("signal"),
 	PROPERTY = Symbol.named("property"), -- will default to nil
-})
+}) :: TieDefinitionTypes
+
+TieDefinition.Realms = TieRealms :: TieRealms.TieRealms
 
-TieDefinition.Realms = TieRealms
+export type TieDefinition<T> = typeof(setmetatable(
+	{} :: {
+		_definitionName: string,
+		_memberMap: { [string]: any },
+		_defaultTieRealm: TieRealms.TieRealm,
+		_validContainerNameSetWeakCache: { [TieRealms.TieRealm]: { [string]: boolean } },
+
+		Server: TieDefinition<T>,
+		Client: TieDefinition<T>,
+	},
+	{} :: typeof({ __index = TieDefinition })
+))
+
+export type TieMemberMap = {
+	[string | TieRealms.TieRealm]: TieDefinitionType | TieMemberMap | any,
+}
 
 --[=[
 	Constructs a new TieDefinition with the given members
@@ -88,11 +125,11 @@ TieDefinition.Realms = TieRealms
 	@param members any
 	@return TieDefinition
 ]=]
-function TieDefinition.new(definitionName: string, members)
-	local self = setmetatable({}, TieDefinition)
+function TieDefinition.new<T>(definitionName: string, members: TieMemberMap): TieDefinition<T>
+	local self: TieDefinition<T> = setmetatable({} :: any, TieDefinition)
 
 	self._definitionName = assert(definitionName, "No definitionName")
-	self._validContainerNameSetWeakCache = setmetatable({}, { __mode = "kv" })
+	self._validContainerNameSetWeakCache = setmetatable({} :: any, { __mode = "kv" })
 	self._memberMap = {}
 	self._defaultTieRealm = TieRealms.SHARED
 
@@ -103,18 +140,18 @@ function TieDefinition.new(definitionName: string, members)
 		_defaultTieRealm = TieRealms.SERVER,
 	}, {
 		__index = self,
-	})
+	}) :: any
 
 	self.Client = setmetatable({
 		_defaultTieRealm = TieRealms.CLIENT,
 	}, {
 		__index = self,
-	})
+	}) :: any
 
 	return self
 end
 
-function TieDefinition:_addMembers(members, realm)
+function TieDefinition._addMembers<T>(self: TieDefinition<T>, members, realm)
 	for memberName, memberTypeOrDefaultValue in members do
 		if TieRealmUtils.isTieRealm(memberName) then
 			self:_addMembers(memberTypeOrDefaultValue, memberName)
@@ -131,7 +168,7 @@ function TieDefinition:_addMembers(members, realm)
 	end
 end
 
-function TieDefinition:_addMember(memberName: string, memberTypeOrDefaultValue, realm: TieRealm)
+function TieDefinition._addMember<T>(self: TieDefinition<T>, memberName: string, memberTypeOrDefaultValue, realm: TieRealm)
 	if memberTypeOrDefaultValue == TieDefinition.Types.METHOD then
 		self._memberMap[memberName] = TieMethodDefinition.new(self, memberName, realm)
 	elseif memberTypeOrDefaultValue == TieDefinition.Types.SIGNAL then
@@ -147,15 +184,20 @@ end
 	Gets all valid interfaces for this adornee
 	@param adornee Instance
 	@param tieRealm TieRealm?
-	@return { TieInterface }
+	@return { TieInterface<T> }
 ]=]
-function TieDefinition:GetImplementations(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.GetImplementations<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): { TieInterface.TieInterface<T> }
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
-	local implementations = {}
+	local implementations: { TieInterface.TieInterface<T> } = {}
 
 	for _, item in self:GetImplementationParents(adornee, tieRealm) do
 		table.insert(implementations, TieInterface.new(self, item, nil, tieRealm))
@@ -164,7 +206,7 @@ function TieDefinition:GetImplementations(adornee: Instance, tieRealm: TieRealm?
 	return implementations
 end
 
-function TieDefinition:GetNewImplClass(tieRealm: TieRealm): string
+function TieDefinition.GetNewImplClass<T>(_self: TieDefinition<T>, tieRealm: TieRealm): string
 	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
 
 	if tieRealm == TieRealms.CLIENT then
@@ -174,20 +216,7 @@ function TieDefinition:GetNewImplClass(tieRealm: TieRealm): string
 	end
 end
 
-local IMPL_CLIENT_SET = table.freeze({
-	["Configuration"] = true,
-})
-
-local IMPL_SERVER_SET = table.freeze({
-	["Camera"] = true,
-})
-
-local IMPL_SHARED_SET = table.freeze({
-	["Camera"] = true,
-	["Configuration"] = true,
-})
-
-function TieDefinition:GetImplClassSet(tieRealm: TieRealm): { [string]: boolean }
+function TieDefinition.GetImplClassSet<T>(_self: TieDefinition<T>, tieRealm: TieRealm): { [string]: boolean }
 	if tieRealm == TieRealms.CLIENT then
 		-- Shared implements both...
 		return IMPL_CLIENT_SET
@@ -200,11 +229,16 @@ function TieDefinition:GetImplClassSet(tieRealm: TieRealm): { [string]: boolean
 	end
 end
 
-function TieDefinition:GetImplementationParents(adornee: BasePart, tieRealm: TieRealm?): { Instance }
+function TieDefinition.GetImplementationParents<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): { Instance }
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	local validContainerNameSet = self:GetValidContainerNameSet(tieRealm)
 
@@ -226,17 +260,21 @@ end
 
 	@param adornee Instance
 	@param tieRealm TieRealm?
-	@return Observable<Brio<TieInterface>>
+	@return Observable<Brio<TieImplementation<T>>>
 ]=]
-function TieDefinition:ObserveChildrenBrio(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.ObserveChildrenBrio<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): Observable.Observable<Brio.Brio<TieImplementation.TieImplementation<T>>>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	return RxInstanceUtils.observeChildrenBrio(adornee):Pipe({
 		RxBrioUtils.flatMapBrio(function(child)
 			return self:ObserveBrio(child, tieRealm)
-		end),
-	})
+		end) :: any,
+	}) :: any
 end
 
 --[=[
@@ -246,7 +284,11 @@ end
 	@param tieRealm TieRealm?
 	@return Promise<TieInterface>
 ]=]
-function TieDefinition:Promise(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.Promise<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): Promise.Promise<TieInterface.TieInterface<T>>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
@@ -255,11 +297,22 @@ function TieDefinition:Promise(adornee: Instance, tieRealm: TieRealm?)
 	return Rx.toPromise(self:Observe(adornee, tieRealm):Pipe({
 		Rx.where(function(value)
 			return value ~= nil
-		end),
-	}))
+		end) :: any,
+	}) :: any)
 end
 
-function TieDefinition:Wait(adornee: Instance, tieRealm: TieRealm?)
+--[=[
+	Waits for the implementation
+
+	@param adornee Adornee
+	@param tieRealm TieRealm?
+	@return TieInterface
+]=]
+function TieDefinition.Wait<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): TieInterface.TieInterface<T>
 	return self:Promise(adornee, tieRealm):Wait()
 end
 
@@ -270,16 +323,20 @@ end
 	@param tieRealm TieRealm?
 	@return { TieInterface }
 ]=]
-function TieDefinition:GetChildren(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.GetChildren<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): { TieInterface.TieInterface<T> }
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 
-	local implementations = {}
+	local implementations: { TieInterface.TieInterface<T> } = {}
 
 	-- TODO: Make this faster
 	for _, item in adornee:GetChildren() do
 		for _, option in self:GetImplementations(item, tieRealm) do
-			table.insert(implementations, option)
+			table.insert(implementations, option :: any)
 		end
 	end
 
@@ -293,7 +350,11 @@ end
 	@param tieRealm TieRealm?
 	@return TieInterface | nil
 ]=]
-function TieDefinition:Find(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.Find<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): TieInterface.TieInterface<T>?
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
@@ -307,15 +368,19 @@ end
 	@param tieRealm TieRealm?
 	@return TieInterface | nil
 ]=]
-function TieDefinition:ObserveAllTaggedBrio(tagName: string, tieRealm: TieRealm?)
+function TieDefinition.ObserveAllTaggedBrio<T>(
+	self: TieDefinition<T>,
+	tagName: string,
+	tieRealm: TieRealm?
+): Observable.Observable<Brio.Brio<TieInterface.TieInterface<T>>>
 	assert(type(tagName) == "string", "Bad tagName")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	return RxCollectionServiceUtils.observeTaggedBrio(tagName):Pipe({
 		RxBrioUtils.flatMapBrio(function(instance)
 			return self:ObserveBrio(instance, tieRealm)
-		end),
-	})
+		end) :: any,
+	}) :: any
 end
 
 --[=[
@@ -324,11 +389,16 @@ end
 	@param tieRealm TieRealm?
 	@return TieInterface
 ]=]
-function TieDefinition:FindFirstImplementation(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.FindFirstImplementation<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): TieInterface.TieInterface<T>?
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	local validContainerNameSet = self:GetValidContainerNameSet(tieRealm)
 	for _, item in adornee:GetChildren() do
@@ -348,11 +418,12 @@ end
 	@param tieRealm TieRealm?
 	@return boolean
 ]=]
-function TieDefinition:HasImplementation(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.HasImplementation<T>(self: TieDefinition<T>, adornee: Instance, tieRealm: TieRealm?): boolean
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	-- TODO: Maybe something faster
 	for containerName, _ in pairs(self:GetValidContainerNameSet(tieRealm)) do
@@ -375,18 +446,22 @@ end
 	@param tieRealm TieRealm?
 	@return Observable<boolean>>
 ]=]
-function TieDefinition:ObserveIsImplemented(adornee: Instance, tieRealm: TieRealm?): Observable.Observable<boolean>
+function TieDefinition.ObserveIsImplemented<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): Observable.Observable<boolean>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	return self:ObserveLastImplementationBrio(adornee, tieRealm):Pipe({
 		RxBrioUtils.map(function(result)
 			return result and true or false
-		end),
-		RxBrioUtils.emitOnDeath(false),
+		end) :: any,
+		RxBrioUtils.emitOnDeath(false) :: any,
 		Rx.defaultsTo(false) :: any,
 		Rx.distinct() :: any,
-	})
+	}) :: any
 end
 
 --[=[
@@ -395,7 +470,8 @@ end
 	@param tieRealm TieRealm?
 	@return Observable<boolean>>
 ]=]
-function TieDefinition:ObserveIsImplementation(
+function TieDefinition.ObserveIsImplementation<T>(
+	self: TieDefinition<T>,
 	implParent: Instance,
 	tieRealm: TieRealm?
 ): Observable.Observable<boolean>
@@ -403,15 +479,16 @@ function TieDefinition:ObserveIsImplementation(
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
-	return self:_observeImplementation(implParent, tieRealm):Pipe({
+	return self:_observeImplementedInterface(implParent, tieRealm):Pipe({
 		RxBrioUtils.map(function(result)
 			return result and true or false
-		end),
-		RxBrioUtils.emitOnDeath(false),
-		Rx.defaultsTo(false),
-		Rx.distinct(),
-	})
+		end) :: any,
+		RxBrioUtils.emitOnDeath(false) :: any,
+		Rx.defaultsTo(false) :: any,
+		Rx.distinct() :: any,
+	}) :: any
 end
 
 --[=[
@@ -421,7 +498,8 @@ end
 	@param tieRealm TieRealm?
 	@return Observable<boolean>>
 ]=]
-function TieDefinition:ObserveIsImplementedOn(
+function TieDefinition.ObserveIsImplementedOn<T>(
+	self: TieDefinition<T>,
 	implParent: Instance,
 	adornee: Instance,
 	tieRealm: TieRealm?
@@ -431,20 +509,21 @@ function TieDefinition:ObserveIsImplementedOn(
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	return RxInstanceUtils.observePropertyBrio(implParent, "Parent", function(parent)
 		return parent == adornee
 	end):Pipe({
 		RxBrioUtils.switchMapBrio(function()
-			return self:_observeImplementation(implParent, tieRealm)
-		end),
+			return self:_observeImplementedInterface(implParent, tieRealm)
+		end) :: any,
 		RxBrioUtils.map(function(result)
 			return result and true or false
-		end),
-		RxBrioUtils.emitOnDeath(false),
-		Rx.defaultsTo(false),
-		Rx.distinct(),
-	})
+		end) :: any,
+		RxBrioUtils.emitOnDeath(false) :: any,
+		Rx.defaultsTo(false) :: any,
+		Rx.distinct() :: any,
+	}) :: any
 end
 
 --[=[
@@ -452,20 +531,25 @@ end
 
 	@param adornee Instance
 	@param tieRealm TieRealm?
-	@return Observable<Brio<TieImplementation<T>>>
+	@return Observable<Brio<TieInterface<T>>>
 ]=]
-function TieDefinition:ObserveBrio(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.ObserveBrio<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): Observable.Observable<Brio.Brio<TieInterface.TieInterface<T>>>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	return self:ObserveValidContainerChildrenBrio(adornee, tieRealm):Pipe({
 		RxBrioUtils.switchMapBrio(function(implParent)
-			return self:_observeImplementation(implParent, tieRealm)
-		end),
-		RxBrioUtils.onlyLastBrioSurvives(),
-	})
+			return self:_observeImplementedInterface(implParent, tieRealm)
+		end) :: any,
+		RxBrioUtils.onlyLastBrioSurvives() :: any,
+	}) :: any
 end
 
 --[=[
@@ -473,15 +557,19 @@ end
 
 	@param adornee Instance
 	@param tieRealm TieRealm?
-	@return Observable<TieImplementation<T> | nil>>
+	@return Observable<TieInterface<T>?>>
 ]=]
-function TieDefinition:Observe(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.Observe<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): Observable.Observable<TieInterface.TieInterface<T>?>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	return self:ObserveBrio(adornee, tieRealm):Pipe({
-		RxStateStackUtils.topOfStack(),
-	})
+		RxStateStackUtils.topOfStack() :: any,
+	}) :: any
 end
 
 TieDefinition.ObserveLastImplementation = TieDefinition.Observe
@@ -491,22 +579,38 @@ TieDefinition.ObserveLastImplementationBrio = TieDefinition.ObserveBrio
 	Observes valid implementations wrapped in a brio if it exists.
 	@param adornee Instance
 	@param tieRealm TieRealm?
-	@return Observable<Brio<TieImplementation<T>>>
+	@return Observable<Brio<TieInterface<T>>>
 ]=]
-function TieDefinition:ObserveImplementationsBrio(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.ObserveImplementationsBrio<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm?
+): Observable.Observable<Brio.Brio<TieInterface.TieInterface<T>>>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	return self:ObserveValidContainerChildrenBrio(adornee, tieRealm):Pipe({
 		RxBrioUtils.flatMapBrio(function(implParent)
-			return self:_observeImplementation(implParent, tieRealm)
-		end),
-	})
+			return self:_observeImplementedInterface(implParent, tieRealm)
+		end) :: any,
+	}) :: any
 end
 
-function TieDefinition:ObserveValidContainerChildrenBrio(adornee: Instance, tieRealm: TieRealm?)
+--[=[
+	Observes valid container children for this adornee that could be implementations.
+
+	@param adornee Instance
+	@param tieRealm TieRealm
+	@return Observable<Brio<Instance>>
+]=]
+function TieDefinition.ObserveValidContainerChildrenBrio<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	tieRealm: TieRealm
+): Observable.Observable<Brio.Brio<Instance>>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
 
@@ -519,7 +623,11 @@ function TieDefinition:ObserveValidContainerChildrenBrio(adornee: Instance, tieR
 	end)
 end
 
-function TieDefinition:_observeImplementation(implParent: Instance, tieRealm: TieRealm?)
+function TieDefinition._observeImplementedInterface<T>(
+	self: TieDefinition<T>,
+	implParent: Instance,
+	tieRealm: TieRealm
+): Observable.Observable<Brio.Brio<TieInterface.TieInterface<T>>>
 	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
 
 	return Observable.new(function(sub)
@@ -580,7 +688,7 @@ function TieDefinition:_observeImplementation(implParent: Instance, tieRealm: Ti
 		update()
 
 		return maid
-	end)
+	end) :: any
 end
 
 --[=[
@@ -596,7 +704,12 @@ end
 	@param tieRealm TieRealm?
 	@return TieImplementation<T>
 ]=]
-function TieDefinition:Implement(adornee: Instance, implementer, tieRealm: TieRealm?)
+function TieDefinition.Implement<T>(
+	self: TieDefinition<T>,
+	adornee: Instance,
+	implementer: T,
+	tieRealm: TieRealm?
+): TieImplementation.TieImplementation<T>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(type(implementer) == "table" or implementer == nil, "Bad implementer")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
@@ -620,11 +733,12 @@ end
 	@param tieRealm TieRealm?
 	@return TieInterface<T>
 ]=]
-function TieDefinition:Get(adornee: Instance, tieRealm: TieRealm?)
+function TieDefinition.Get<T>(self: TieDefinition<T>, adornee: Instance, tieRealm: TieRealm?): TieInterface.TieInterface<T>
 	assert(typeof(adornee) == "Instance", "Bad adornee")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 
 	tieRealm = tieRealm or self._defaultTieRealm
+	assert(tieRealm, "Typechecking assertion")
 
 	return TieInterface.new(self, nil, adornee, tieRealm)
 end
@@ -633,7 +747,7 @@ end
 	Gets the name of the definition
 	@return string
 ]=]
-function TieDefinition:GetName(): string
+function TieDefinition.GetName<T>(self: TieDefinition<T>): string
 	return self._definitionName
 end
 
@@ -643,7 +757,7 @@ end
 	@param tieRealm TieRealm
 	@return { [string]: boolean }
 ]=]
-function TieDefinition:GetValidContainerNameSet(tieRealm: TieRealm?): { [string]: boolean }
+function TieDefinition.GetValidContainerNameSet<T>(self: TieDefinition<T>, tieRealm: TieRealm): { [string]: boolean }
 	-- TODO: Still generate unique datamodel key here?
 	if self._validContainerNameSetWeakCache[tieRealm] then
 		return self._validContainerNameSetWeakCache[tieRealm]
@@ -683,7 +797,7 @@ end
 	@param tieRealm TieRealm
 	@return string
 ]=]
-function TieDefinition:GetNewContainerName(tieRealm: TieRealm): string
+function TieDefinition.GetNewContainerName<T>(self: TieDefinition<T>, tieRealm: TieRealm): string
 	assert(TieRealmUtils.isTieRealm(tieRealm), "Bad tieRealm")
 
 	-- TODO: Handle server/actor
@@ -700,7 +814,7 @@ function TieDefinition:GetNewContainerName(tieRealm: TieRealm): string
 	end
 end
 
-function TieDefinition:GetMemberMap()
+function TieDefinition.GetMemberMap<T>(self: TieDefinition<T>)
 	return self._memberMap
 end
 
@@ -711,7 +825,7 @@ end
 	@param tieRealm TieRealm? -- Optional tie realm
 	@return boolean
 ]=]
-function TieDefinition:IsImplementation(implParent: Instance, tieRealm: TieRealm?): boolean
+function TieDefinition.IsImplementation<T>(self: TieDefinition<T>, implParent: Instance, tieRealm: TieRealm?): boolean
 	assert(typeof(implParent) == "Instance", "Bad implParent")
 	assert(TieRealmUtils.isTieRealm(tieRealm) or tieRealm == nil, "Bad tieRealm")
 

package/src/Shared/TieImplementation.lua

@@ -18,6 +18,21 @@ local TieImplementation = setmetatable({}, BaseObject)
 TieImplementation.ClassName = "TieImplementation"
 TieImplementation.__index = TieImplementation
 
+export type TieImplementation<T> =
+	typeof(setmetatable(
+		{} :: {
+			_tieDefinition: any,
+			_adornee: Instance,
+			_actualSelf: any,
+			_implementationTieRealm: TieRealms.TieRealm,
+			_implParent: Instance,
+			_memberImplementations: { [string]: any },
+			_memberMap: { [string]: any },
+		},
+		{} :: typeof({ __index = TieImplementation })
+	))
+	& T
+
 --[=[
 	Constructs a new implementation. Use [TieDefinition.Implement] instead of using this directly.
 
@@ -26,15 +41,15 @@ TieImplementation.__index = TieImplementation
 	@param implementer table
 	@param implementationTieRealm TieRealm
 ]=]
-function TieImplementation.new(
+function TieImplementation.new<T>(
 	tieDefinition,
 	adornee: Instance,
 	implementer,
 	implementationTieRealm: TieRealms.TieRealm
-)
+): TieImplementation<T>
 	assert(TieRealmUtils.isTieRealm(implementationTieRealm), "Bad implementationTieRealm")
 
-	local self = setmetatable(BaseObject.new(), TieImplementation)
+	local self: TieImplementation<T> = setmetatable(BaseObject.new() :: any, TieImplementation)
 
 	self._tieDefinition = assert(tieDefinition, "No definition")
 	self._adornee = assert(adornee, "No adornee")
@@ -56,22 +71,22 @@ function TieImplementation.new(
 		self._maid:DoCleaning()
 
 		for key, _ in pairs(self) do
-			rawset(self, key, nil)
+			rawset(self :: any, key, nil)
 		end
 	end)
 
 	return self
 end
 
-function TieImplementation:GetImplementationTieRealm()
+function TieImplementation.GetImplementationTieRealm<T>(self: TieImplementation<T>): TieRealms.TieRealm
 	return self._implementationTieRealm
 end
 
-function TieImplementation:GetImplParent()
+function TieImplementation.GetImplParent<T>(self: TieImplementation<T>): Instance
 	return self._implParent
 end
 
-function TieImplementation:__index(index)
+function TieImplementation.__index<T>(self: TieImplementation<T>, index)
 	if TieImplementation[index] then
 		return TieImplementation[index]
 	end
@@ -85,12 +100,12 @@ function TieImplementation:__index(index)
 		or index == "_memberMap"
 		or index == "_actualSelf"
 	then
-		return rawget(self, index)
+		return rawget(self :: any, index)
 	end
 
-	local memberMap = rawget(self, "_memberMap")
+	local memberMap = rawget(self :: any, "_memberMap")
 	local memberDefinition = memberMap[index]
-	local implementationTieRealm = rawget(self, "_implementationTieRealm")
+	local implementationTieRealm = rawget(self :: any, "_implementationTieRealm")
 
 	if memberDefinition then
 		if memberDefinition:IsAllowedForImplementation(self._implementationTieRealm) then
@@ -109,7 +124,7 @@ function TieImplementation:__index(index)
 	end
 end
 
-function TieImplementation:__newindex(index, value)
+function TieImplementation.__newindex<T>(self: TieImplementation<T>, index, value)
 	if
 		index == "_implParent"
 		or index == "_adornee"
@@ -119,7 +134,7 @@ function TieImplementation:__newindex(index, value)
 		or index == "_memberMap"
 		or index == "_actualSelf"
 	then
-		rawset(self, index, value)
+		rawset(self :: any, index, value)
 	elseif self._memberImplementations[index] then
 		self._memberImplementations[index]:SetImplementation(value, self._actualSelf)
 	elseif TieImplementation[index] then
@@ -129,7 +144,7 @@ function TieImplementation:__newindex(index, value)
 	end
 end
 
-function TieImplementation:_buildMemberImplementations(implementer)
+function TieImplementation._buildMemberImplementations<T>(self: TieImplementation<T>, implementer)
 	for _, memberDefinition in self._memberMap do
 		local memberName = memberDefinition:GetMemberName()
 		local found = nil
@@ -159,7 +174,7 @@ function TieImplementation:_buildMemberImplementations(implementer)
 	self._implParent.Name = self._tieDefinition:GetNewContainerName(self._implementationTieRealm)
 end
 
-function TieImplementation:_getErrorMessageForNotAllowedMember(memberDefinition)
+function TieImplementation._getErrorMessageForNotAllowedMember<T>(self: TieImplementation<T>, memberDefinition)
 	local errorMessage = string.format(
 		"[TieImplementation] - Member implements %s only member %s (we are a %s implementation)",
 		memberDefinition:GetMemberTieRealm(),
@@ -182,7 +197,7 @@ function TieImplementation:_getErrorMessageForNotAllowedMember(memberDefinition)
 	return errorMessage
 end
 
-function TieImplementation:_getErrorMessageRequiredMember(memberDefinition)
+function TieImplementation._getErrorMessageRequiredMember<T>(self: TieImplementation<T>, memberDefinition)
 	local errorMessage = string.format(
 		"[TieImplementation] - Missing %s member %s (we are a %s implementation)",
 		memberDefinition:GetMemberTieRealm(),

package/src/Shared/TieInterface.lua

@@ -7,16 +7,36 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local Observable = require("Observable")
 local TieMethodInterfaceUtils = require("TieMethodInterfaceUtils")
 local TiePropertyInterface = require("TiePropertyInterface")
+local TieRealms = require("TieRealms")
 local TieSignalInterface = require("TieSignalInterface")
 
 local TieInterface = {}
 TieInterface.ClassName = "TieInterface"
 TieInterface.__index = TieInterface
 
-function TieInterface.new(definition, implParent: Instance?, adornee: Instance?, interfaceTieRealm)
-	local self = setmetatable({}, TieInterface)
+export type TieInterface<T> =
+	typeof(setmetatable(
+		{} :: {
+			_definition: any,
+			_implParent: Instance?,
+			_adornee: Instance?,
+			_interfaceTieRealm: string,
+			_memberDefinitionMap: { [string]: any },
+		},
+		{} :: typeof({ __index = TieInterface })
+	))
+	& T
+
+function TieInterface.new<T>(
+	definition,
+	implParent: Instance?,
+	adornee: Instance?,
+	interfaceTieRealm: TieRealms.TieRealm
+): TieInterface<T>
+	local self: TieInterface<T> = setmetatable({} :: any, TieInterface)
 
 	assert(implParent or adornee, "ImplParent or adornee required")
 
@@ -34,11 +54,11 @@ end
 
 	@return boolean
 ]=]
-function TieInterface:IsImplemented(): boolean
-	local implParent = rawget(self, "_implParent")
-	local adornee = rawget(self, "_adornee")
-	local definition = rawget(self, "_definition")
-	local interfaceTieRealm = rawget(self, "_interfaceTieRealm")
+function TieInterface.IsImplemented<T>(self: TieInterface<T>): boolean
+	local implParent = rawget(self :: any, "_implParent")
+	local adornee = rawget(self :: any, "_adornee")
+	local definition = rawget(self :: any, "_definition")
+	local interfaceTieRealm = rawget(self :: any, "_interfaceTieRealm")
 
 	if implParent then
 		if adornee then
@@ -62,13 +82,13 @@ end
 
 	@return Instance?
 ]=]
-function TieInterface:GetTieAdornee(): Instance?
-	local adornee = rawget(self, "_adornee")
+function TieInterface.GetTieAdornee<T>(self: TieInterface<T>): Instance?
+	local adornee = rawget(self :: any, "_adornee")
 	if adornee then
 		return adornee
 	end
 
-	local implParent = rawget(self, "_implParent")
+	local implParent = rawget(self :: any, "_implParent")
 	if implParent then
 		return implParent.Parent
 	end
@@ -81,11 +101,11 @@ end
 
 	@return Observable<boolean>
 ]=]
-function TieInterface:ObserveIsImplemented()
-	local implParent = rawget(self, "_implParent")
-	local adornee = rawget(self, "_adornee")
-	local definition = rawget(self, "_definition")
-	local interfaceTieRealm = rawget(self, "_interfaceTieRealm")
+function TieInterface.ObserveIsImplemented<T>(self: TieInterface<T>): Observable.Observable<boolean>
+	local implParent = rawget(self :: any, "_implParent")
+	local adornee = rawget(self :: any, "_adornee")
+	local definition = rawget(self :: any, "_definition")
+	local interfaceTieRealm = rawget(self :: any, "_interfaceTieRealm")
 
 	if implParent then
 		if adornee then
@@ -98,13 +118,13 @@ function TieInterface:ObserveIsImplemented()
 	return definition:ObserveIsImplemented(adornee, interfaceTieRealm)
 end
 
-function TieInterface:__index(index)
-	local interfaceTieRealm = rawget(self, "_interfaceTieRealm")
+function TieInterface.__index<T>(self: TieInterface<T>, index)
+	local interfaceTieRealm = rawget(self :: any, "_interfaceTieRealm")
 
-	local member = (rawget(self, "_memberDefinitionMap") :: any)[index]
-	local definition = rawget(self, "_definition")
-	local adornee = rawget(self, "_adornee")
-	local implParent = rawget(self, "_implParent")
+	local member = (rawget(self :: any, "_memberDefinitionMap") :: any)[index]
+	local definition = rawget(self :: any, "_definition")
+	local adornee = rawget(self :: any, "_adornee")
+	local implParent = rawget(self :: any, "_implParent")
 
 	if member then
 		if member:IsAllowedOnInterface(interfaceTieRealm) then