@quenty/remoting 12.18.0 → 12.18.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [12.18.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/remoting@12.18.0...@quenty/remoting@12.18.1) (2025-04-05)
+
+
+### Bug Fixes
+
+* Add types to packages ([2374fb2](https://github.com/Quenty/NevermoreEngine/commit/2374fb2b043cfbe0e9b507b3316eec46a4e353a0))
+
+
+
+
+
 # [12.18.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/remoting@12.17.2...@quenty/remoting@12.18.0) (2025-04-02)
 
 **Note:** Version bump only for package @quenty/remoting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/remoting",
-  "version": "12.18.0",
+  "version": "12.18.1",
   "description": "Global remoting retrieval system for Roblox (RemoteFunctions/RemoteEvents)",
   "keywords": [
     "Roblox",
@@ -26,18 +26,18 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/brio": "^14.17.0",
-    "@quenty/instanceutils": "^13.17.0",
-    "@quenty/loader": "^10.8.0",
-    "@quenty/maid": "^3.4.0",
-    "@quenty/promise": "^10.10.1",
-    "@quenty/promisemaid": "^5.10.1",
-    "@quenty/remotefunctionutils": "^10.10.1",
-    "@quenty/rx": "^13.17.0",
-    "@quenty/table": "^3.7.1"
+    "@quenty/brio": "^14.17.1",
+    "@quenty/instanceutils": "^13.17.1",
+    "@quenty/loader": "^10.8.1",
+    "@quenty/maid": "^3.4.1",
+    "@quenty/promise": "^10.10.2",
+    "@quenty/promisemaid": "^5.10.2",
+    "@quenty/remotefunctionutils": "^10.10.2",
+    "@quenty/rx": "^13.17.1",
+    "@quenty/table": "^3.7.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e8ea56930e65322fcffc05a1556d5df988068f0b"
+  "gitHead": "78c3ac0ab08dd18085b6e6e6e4f745e76ed99f68"
 }

package/src/Shared/GetRemoteEvent.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Provides getting named global [RemoteEvent] resources.
 	@class GetRemoteEvent
@@ -45,7 +46,7 @@ local RunService = game:GetService("RunService")
 local ResourceConstants = require("ResourceConstants")
 
 if not RunService:IsRunning() then
-	return function(name)
+	return function(name: string): RemoteEvent
 		local event = Instance.new("RemoteEvent")
 		event.Archivable = false
 		event.Name = "Mock" .. name
@@ -53,33 +54,45 @@ if not RunService:IsRunning() then
 		return event
 	end
 elseif RunService:IsServer() then
-	return function(name)
-		assert(type(name) == "string", "Bad name")
-
+	local function getOrCreateStorage(): Instance
 		local storage = ReplicatedStorage:FindFirstChild(ResourceConstants.REMOTE_EVENT_STORAGE_NAME)
-		if not storage then
-			storage = Instance.new("Folder")
-			storage.Name = ResourceConstants.REMOTE_EVENT_STORAGE_NAME
-			storage.Archivable = false
-			storage.Parent = ReplicatedStorage
+		if storage then
+			return storage
 		end
 
+		local created = Instance.new("Folder")
+		created.Name = ResourceConstants.REMOTE_EVENT_STORAGE_NAME
+		created.Archivable = false
+		created.Parent = ReplicatedStorage
+		return created
+	end
+
+	return function(name: string): RemoteEvent
+		assert(type(name) == "string", "Bad name")
+
+		local storage = getOrCreateStorage()
+
 		local event = storage:FindFirstChild(name)
-		if event then
+		if event and event:IsA("RemoteEvent") then
 			return event
 		end
 
-		event = Instance.new("RemoteEvent")
-		event.Name = name
-		event.Archivable = false
-		event.Parent = storage
+		local created = Instance.new("RemoteEvent")
+		created.Name = name
+		created.Archivable = false
+		created.Parent = storage
 
-		return event
+		return created
 	end
 else -- RunService:IsClient()
-	return function(name)
+	return function(name: string): RemoteEvent
 		assert(type(name) == "string", "Bad name")
 
-		return ReplicatedStorage:WaitForChild(ResourceConstants.REMOTE_EVENT_STORAGE_NAME):WaitForChild(name)
+		local found = ReplicatedStorage:WaitForChild(ResourceConstants.REMOTE_EVENT_STORAGE_NAME):WaitForChild(name)
+		if found and found:IsA("RemoteEvent") then
+			return found
+		end
+
+		error("Could not find remote event " .. name)
 	end
 end

package/src/Shared/GetRemoteFunction.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Provides getting named global [RemoteFunction] resources.
 
@@ -48,7 +49,7 @@ local RunService = game:GetService("RunService")
 local ResourceConstants = require("ResourceConstants")
 
 if not RunService:IsRunning() then
-	return function(name)
+	return function(name: string): RemoteFunction
 		local func = Instance.new("RemoteFunction")
 		func.Name = "Mock" .. name
 		func.Archivable = false
@@ -56,33 +57,45 @@ if not RunService:IsRunning() then
 		return func
 	end
 elseif RunService:IsServer() then
-	return function(name)
-		assert(type(name) == "string", "Bad name")
-
+	local function getOrCreateStorage(): Instance
 		local storage = ReplicatedStorage:FindFirstChild(ResourceConstants.REMOTE_FUNCTION_STORAGE_NAME)
-		if not storage then
-			storage = Instance.new("Folder")
-			storage.Name = ResourceConstants.REMOTE_FUNCTION_STORAGE_NAME
-			storage.Archivable = false
-			storage.Parent = ReplicatedStorage
+		if storage then
+			return storage
 		end
 
+		local created = Instance.new("Folder")
+		created.Name = ResourceConstants.REMOTE_FUNCTION_STORAGE_NAME
+		created.Archivable = false
+		created.Parent = ReplicatedStorage
+
+		return created
+	end
+
+	return function(name: string): RemoteFunction
+		assert(type(name) == "string", "Bad name")
+
+		local storage = getOrCreateStorage()
 		local func = storage:FindFirstChild(name)
-		if func then
+		if func and func:IsA("RemoteFunction") then
 			return func
 		end
 
-		func = Instance.new("RemoteFunction")
-		func.Name = name
-		func.Archivable = false
-		func.Parent = storage
+		local created = Instance.new("RemoteFunction")
+		created.Name = name
+		created.Archivable = false
+		created.Parent = storage
 
-		return func
+		return created
 	end
 else -- RunService:IsClient()
-	return function(name)
+	return function(name: string): RemoteFunction
 		assert(type(name) == "string", "Bad name")
 
-		return ReplicatedStorage:WaitForChild(ResourceConstants.REMOTE_FUNCTION_STORAGE_NAME):WaitForChild(name)
+		local found = ReplicatedStorage:WaitForChild(ResourceConstants.REMOTE_FUNCTION_STORAGE_NAME):WaitForChild(name)
+		if found and found:IsA("RemoteFunction") then
+			return found
+		end
+
+		error("Could not find remote function " .. name)
 	end
 end

package/src/Shared/Interface/Remoting.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Offers a thin wrapper around Roblox remoting instances and events. Designed to reduce
 	the amount of code needed to construct a large set of RemoteFunction/RemoteEvent instances.
@@ -20,14 +21,16 @@ local RemotingRealms = require("RemotingRealms")
 local RemotingRealmUtils = require("RemotingRealmUtils")
 local RxBrioUtils = require("RxBrioUtils")
 local RxInstanceUtils = require("RxInstanceUtils")
+local _Observable = require("Observable")
+local _Brio = require("Brio")
 
 local RAW_MEMBERS = {
-	_name = true;
-	_maid = true;
-	_instance = true;
-	_remoteObjects = true;
-	_container = true;
-	_defaultRemotingRealm = true;
+	_name = true,
+	_maid = true,
+	_instance = true,
+	_remoteObjects = true,
+	_container = true,
+	_defaultRemotingRealm = true,
 }
 
 local REMOTE_EVENT_SUFFIX = "Event"
@@ -40,17 +43,77 @@ Remoting.__index = Remoting
 Remoting.Realms = RemotingRealms
 
 Remoting.Server = {
-	new = function(instance, name)
+	new = function(instance: Instance, name: string)
 		return Remoting.new(instance, name, RemotingRealms.SERVER)
-	end;
+	end,
 }
 
 Remoting.Client = {
-	new = function(instance, name)
+	new = function(instance: Instance, name: string)
 		return Remoting.new(instance, name, RemotingRealms.CLIENT)
-	end;
+	end,
 }
 
+export type Remoting = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_instance: Instance,
+		_name: string,
+		_remoteObjects: { [string]: RemoteEvent | BindableEvent | RemoteFunction },
+		_container: Folder?,
+		_remotingRealm: RemotingRealms.RemotingRealm,
+		_useDummyObject: boolean,
+		_remoteFolderName: string,
+
+		-- Public methods
+		DeclareEvent: (self: Remoting, memberName: string) -> (),
+		DeclareMethod: (self: Remoting, memberName: string) -> (),
+		Connect: (self: Remoting, memberName: string, callback: (...any) -> ()) -> Maid.Maid,
+		Bind: (self: Remoting, memberName: string, callback: (...any) -> ()) -> Maid.Maid,
+		FireClient: (self: Remoting, memberName: string, player: Player, ...any) -> (),
+		FireAllClients: (self: Remoting, memberName: string, ...any) -> (),
+		FireAllClientsExcept: (self: Remoting, memberName: string, excludePlayer: Player, ...any) -> (),
+		FireServer: (self: Remoting, memberName: string, ...any) -> (),
+		PromiseFireServer: (self: Remoting, memberName: string, ...any) -> Promise.Promise<()>,
+		PromiseInvokeServer: (self: Remoting, memberName: string, ...any) -> Promise.Promise<...any>,
+		GetContainerClass: (self: Remoting) -> string,
+
+		-- Private methods
+		_getDummyMemberName: (self: Remoting, memberName: string, suffix: string) -> string,
+		_getMemberName: (self: Remoting, memberName: string, objectType: string) -> string,
+		_getDebugMemberName: (self: Remoting, memberName: string) -> string,
+		_ensureContainer: (self: Remoting) -> Folder,
+		_observeFolderBrio: (self: Remoting) -> _Observable.Observable<_Brio.Brio<Folder>>,
+		_observeRemoteEventBrio: (
+			self: Remoting,
+			memberName: string
+		) -> _Observable.Observable<_Brio.Brio<RemoteEvent>>,
+		_observeRemoteFunctionBrio: (
+			self: Remoting,
+			memberName: string
+		) -> _Observable.Observable<_Brio.Brio<RemoteFunction>>,
+		_promiseContainer: (self: Remoting, maid: Maid.Maid) -> Promise.Promise<Folder>,
+		_promiseRemoteEvent: (self: Remoting, maid: Maid.Maid, memberName: string) -> Promise.Promise<RemoteEvent>,
+		_getOrCreateRemoteEvent: (self: Remoting, memberName: string) -> RemoteEvent | BindableEvent,
+		_getOrCreateRemoteFunction: (self: Remoting, memberName: string) -> RemoteFunction | BindableFunction,
+		_promiseRemoteFunction: (
+			self: Remoting,
+			maid: Maid.Maid,
+			memberName: string
+		) -> Promise.Promise<RemoteFunction>,
+		_translateCallback: (
+			self: Remoting,
+			maid: Maid.Maid,
+			memberName: string,
+			callback: (...any) -> ...any
+		) -> (...any) -> ...any,
+
+		-- Public remoting member export
+		[string]: RemotingMember.RemotingMember,
+	},
+	Remoting
+))
+
 --[=[
 	Creates a new remoting instance
 
@@ -59,7 +122,7 @@ Remoting.Client = {
 	@param remotingRealm RemotingRealm?
 	@return Remoting
 ]=]
-function Remoting.new(instance, name, remotingRealm)
+function Remoting.new(instance: Instance, name: string, remotingRealm: RemotingRealms.RemotingRealm?): Remoting
 	assert(typeof(instance) == "Instance", "Bad instance")
 	assert(type(name) == "string", "Bad name")
 	assert(RemotingRealmUtils.isRemotingRealm(remotingRealm) or remotingRealm == nil, "Bad remotingRealm")
@@ -76,14 +139,14 @@ function Remoting.new(instance, name, remotingRealm)
 	self._remoteFolderName = string.format("%sRemotes", self._name)
 	self._remoteObjects = {}
 
-	return self
+	return self :: any
 end
 
-function Remoting:__index(index)
+(Remoting :: any).__index = function(self, index)
 	if Remoting[index] then
 		return Remoting[index]
 	elseif RAW_MEMBERS[index] then
-		return rawget(self, index)
+		return rawget(self :: any, index)
 	else
 		return RemotingMember.new(self, index, self._remotingRealm)
 	end
@@ -93,10 +156,10 @@ end
 	Connects to a given remote event.
 
 	@param memberName string
-	@param callback string
+	@param callback (...) -> ()
 	@return MaidTask
 ]=]
-function Remoting:Connect(memberName, callback)
+function Remoting.Connect(self: Remoting, memberName: string, callback: (...any) -> ())
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(type(callback) == "function", "Bad callback")
 
@@ -107,30 +170,39 @@ function Remoting:Connect(memberName, callback)
 			self:DeclareEvent(memberName)
 
 			self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
-			local bindableEvent = self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnServerEvent"))
+			local bindableEvent: BindableEvent =
+				self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnServerEvent")) :: any
 			connectMaid:GiveTask(bindableEvent.Event:Connect(callback))
 		else
-			local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+			local remoteEvent: RemoteEvent = self:_getOrCreateRemoteEvent(memberName) :: any
 			connectMaid:GiveTask(remoteEvent.OnServerEvent:Connect(callback))
 		end
 
 		-- TODO: Cleanup if nothing else is expecting this
 	elseif self._remotingRealm == RemotingRealms.CLIENT then
 		connectMaid._warning = task.delay(5, function()
-			warn(string.format("[Remoting] - Failed to find RemoteEvent %q, event may never connect", self:_getDebugMemberName(memberName)))
+			warn(
+				string.format(
+					"[Remoting] - Failed to find RemoteEvent %q, event may never connect",
+					self:_getDebugMemberName(memberName)
+				)
+			)
 		end)
 
 		if self._useDummyObject then
-			connectMaid:GiveTask(self:_observeRemoteEventBrio(self:_getDummyMemberName(memberName, "OnClientEvent")):Subscribe(function(brio)
-				if brio:IsDead() then
-					return
-				end
-
-				connectMaid._warning = nil
-
-				local maid, remoteEvent = brio:ToMaidAndValue()
-				maid:GiveTask(remoteEvent.Event:Connect(callback))
-			end))
+			connectMaid:GiveTask(
+				self:_observeRemoteEventBrio(self:_getDummyMemberName(memberName, "OnClientEvent"))
+					:Subscribe(function(brio)
+						if brio:IsDead() then
+							return
+						end
+
+						connectMaid._warning = nil
+
+						local maid, bindableEvent: any = brio:ToMaidAndValue()
+						maid:GiveTask((bindableEvent :: BindableEvent).Event:Connect(callback))
+					end)
+			)
 		else
 			connectMaid:GiveTask(self:_observeRemoteEventBrio(memberName):Subscribe(function(brio)
 				if brio:IsDead() then
@@ -147,9 +219,9 @@ function Remoting:Connect(memberName, callback)
 		error("[Remoting.Connect] - Unknown RunService state")
 	end
 
-	self._maid[connectMaid] = connectMaid
+	self._maid[connectMaid :: any] = connectMaid
 	connectMaid:GiveTask(function()
-		self._maid[connectMaid] = nil
+		self._maid[connectMaid :: any] = nil
 	end)
 
 	return connectMaid
@@ -162,42 +234,50 @@ end
 	@param memberName string
 	@param callback any
 ]=]
-function Remoting:Bind(memberName, callback)
+function Remoting.Bind(self: Remoting, memberName: string, callback: (...any) -> ...any)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(type(callback) == "function", "Bad callback")
 
-	local bindMaid = Maid.new()
+	local bindMaid: Maid.Maid = Maid.new()
 
 	if self._remotingRealm == RemotingRealms.SERVER then
 		if self._useDummyObject then
 			self:DeclareMethod(memberName)
 
-			local bindableFunction = self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnServerInvoke"))
+			local bindableFunction: BindableFunction =
+				self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnServerInvoke")) :: any
 			bindableFunction.OnInvoke = self:_translateCallback(bindMaid, memberName, callback)
 		else
-			local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+			local remoteFunction: RemoteFunction = self:_getOrCreateRemoteFunction(memberName) :: any
 			remoteFunction.OnServerInvoke = self:_translateCallback(bindMaid, memberName, callback)
 		end
 
 		-- TODO: Cleanup if nothing else is expecting this
 	elseif self._remotingRealm == RemotingRealms.CLIENT then
 		bindMaid._warning = task.delay(5, function()
-			warn(string.format("[Remoting] - Failed to find RemoteEvent %q, event may never fire", self:_getDebugMemberName(memberName)))
+			warn(
+				string.format(
+					"[Remoting] - Failed to find RemoteEvent %q, event may never fire",
+					self:_getDebugMemberName(memberName)
+				)
+			)
 		end)
 
 		if self._useDummyObject then
-			bindMaid:GiveTask(self:_observeRemoteFunctionBrio(self:_getDummyMemberName(memberName, "OnClientInvoke")):Subscribe(function(brio)
-				if brio:IsDead() then
-					return
-				end
+			bindMaid:GiveTask(
+				self:_observeRemoteFunctionBrio(self:_getDummyMemberName(memberName, "OnClientInvoke"))
+					:Subscribe(function(brio)
+						if brio:IsDead() then
+							return
+						end
 
-				bindMaid._warning = nil
+						bindMaid._warning = nil
 
-				local maid, remoteFunction = brio:ToMaidAndValue()
+				local maid, remoteFunction: any = brio:ToMaidAndValue()
 				remoteFunction.OnInvoke = self:_translateCallback(maid, memberName, callback)
-			end))
+					end)
+			)
 		else
-
 			bindMaid:GiveTask(self:_observeRemoteFunctionBrio(memberName):Subscribe(function(brio)
 				if brio:IsDead() then
 					return
@@ -215,9 +295,9 @@ function Remoting:Bind(memberName, callback)
 		error("[Remoting.Bind] - Unknown RunService state")
 	end
 
-	self._maid[bindMaid] = bindMaid
+	self._maid[bindMaid :: any] = bindMaid
 	bindMaid:GiveTask(function()
-		self._maid[bindMaid] = nil
+		self._maid[bindMaid :: any] = nil
 	end)
 
 	return bindMaid
@@ -228,7 +308,7 @@ end
 
 	@param memberName string
 ]=]
-function Remoting:DeclareEvent(memberName)
+function Remoting.DeclareEvent(self: Remoting, memberName: string)
 	assert(type(memberName) == "string", "Bad memberName")
 
 	if self._remotingRealm == RemotingRealms.SERVER then
@@ -246,7 +326,7 @@ end
 
 	@param memberName string
 ]=]
-function Remoting:DeclareMethod(memberName)
+function Remoting.DeclareMethod(self: Remoting, memberName: string)
 	assert(type(memberName) == "string", "Bad memberName")
 
 	if self._remotingRealm == RemotingRealms.SERVER then
@@ -259,7 +339,7 @@ function Remoting:DeclareMethod(memberName)
 	end
 end
 
-function Remoting:_translateCallback(maid, memberName, callback)
+function Remoting._translateCallback(self: Remoting, maid: Maid.Maid, memberName: string, callback: (...any) -> ...any)
 	local alive = true
 	maid:GiveTask(function()
 		alive = false
@@ -267,14 +347,19 @@ function Remoting:_translateCallback(maid, memberName, callback)
 
 	return function(...)
 		if not alive then
-			error(string.format("[Remoting] - Function for %s is disconnected and can't be called", self:_getDebugMemberName(memberName)))
+			error(
+				string.format(
+					"[Remoting] - Function for %s is disconnected and can't be called",
+					self:_getDebugMemberName(memberName)
+				)
+			)
 			return
 		end
 
 		local results = table.pack(callback(...))
 
 		local hasPromise = false
-		for i=1, results.n do
+		for i = 1, results.n do
 			if Promise.isPromise(results[i]) then
 				hasPromise = true
 				break
@@ -287,7 +372,7 @@ function Remoting:_translateCallback(maid, memberName, callback)
 				promise = results[1]
 			else
 				local data = {}
-				for i=1, results.n do
+				for i = 1, results.n do
 					table.insert(data, results[i])
 				end
 
@@ -319,18 +404,18 @@ end
 	@param player Player
 	@param ... any
 ]=]
-function Remoting:FireClient(memberName, player, ...)
+function Remoting.FireClient(self: Remoting, memberName: string, player: Player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(self._remotingRealm == RemotingRealms.SERVER, "FireClient must be called on server")
 
 	if self._useDummyObject then
-		local bindableEvent = self:_getOrCreateRemoteEvent(memberName)
+		local bindableEvent: BindableEvent = self:_getOrCreateRemoteEvent(memberName) :: any
 		bindableEvent:Fire(...)
 		return
 	end
 
-	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+	local remoteEvent: RemoteEvent = self:_getOrCreateRemoteEvent(memberName) :: any
 	remoteEvent:FireClient(player, ...)
 end
 
@@ -344,18 +429,19 @@ end
 	@param player Player
 	@param ... any
 ]=]
-function Remoting:InvokeClient(memberName, player, ...)
+function Remoting.InvokeClient(self: Remoting, memberName: string, player: Player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(self._remotingRealm == RemotingRealms.SERVER, "InvokeClient must be called on server")
 
 	if self._useDummyObject then
-		local bindableFunction = self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke"))
+		local bindableFunction: BindableFunction =
+			self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke")) :: any
 		bindableFunction:Invoke(...)
 		return
 	end
 
-	local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+	local remoteFunction: RemoteFunction = self:_getOrCreateRemoteFunction(memberName) :: any
 	remoteFunction:InvokeClient(player, ...)
 end
 
@@ -368,17 +454,18 @@ end
 	@param memberName string
 	@param ... any
 ]=]
-function Remoting:FireAllClients(memberName, ...)
+function Remoting.FireAllClients(self: Remoting, memberName: string, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClients must be called on server")
 
 	if self._useDummyObject then
-		local bindableEvent = self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
+		local bindableEvent: BindableEvent =
+			self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent")) :: any
 		bindableEvent:Fire(...)
 		return
 	end
 
-	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+	local remoteEvent: RemoteEvent = self:_getOrCreateRemoteEvent(memberName) :: any
 	remoteEvent:FireAllClients(...)
 end
 
@@ -391,19 +478,23 @@ end
 	@param excludePlayer Player | nil
 	@param ... any
 ]=]
-function Remoting:FireAllClientsExcept(memberName, excludePlayer, ...)
+function Remoting.FireAllClientsExcept(self: Remoting, memberName: string, excludePlayer: Player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
-	assert(typeof(excludePlayer) == "Instance" and excludePlayer:IsA("Player") or excludePlayer == nil, "Bad excludePlayer")
+	assert(
+		typeof(excludePlayer) == "Instance" and excludePlayer:IsA("Player") or excludePlayer == nil,
+		"Bad excludePlayer"
+	)
 	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClientsExcept must be called on server")
 
 	if self._useDummyObject then
-		local bindableEvent = self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
+		local bindableEvent: BindableEvent =
+			self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent")) :: any
 		bindableEvent:Fire(...)
 		return
 	end
 
-	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
-	for _, player in pairs(Players:GetPlayers()) do
+	local remoteEvent: RemoteEvent = self:_getOrCreateRemoteEvent(memberName) :: any
+	for _, player in Players:GetPlayers() do
 		if player ~= excludePlayer then
 			remoteEvent:FireClient(player, ...)
 		end
@@ -417,7 +508,7 @@ end
 	@param memberName string
 	@param ... any
 ]=]
-function Remoting:FireServer(memberName, ...)
+function Remoting.FireServer(self: Remoting, memberName: string, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(self._remotingRealm == RemotingRealms.CLIENT, "FireServer must be called on client")
 
@@ -432,7 +523,7 @@ end
 	@param ... any
 	@return Promise
 ]=]
-function Remoting:PromiseFireServer(memberName, ...)
+function Remoting.PromiseFireServer(self: Remoting, memberName: string, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(self._remotingRealm == RemotingRealms.CLIENT, "PromiseFireServer must be called on client")
 
@@ -446,18 +537,17 @@ function Remoting:PromiseFireServer(memberName, ...)
 				bindableEvent:Fire(Players.LocalPlayer, table.unpack(args, 1, args.n))
 			end)
 	else
-		promise = self:_promiseRemoteEvent(fireMaid, memberName)
-			:Then(function(remoteEvent)
-				remoteEvent:FireServer(table.unpack(args, 1, args.n))
-			end)
+		promise = self:_promiseRemoteEvent(fireMaid, memberName):Then(function(remoteEvent)
+			remoteEvent:FireServer(table.unpack(args, 1, args.n))
+		end)
 	end
 
 	promise:Finally(function()
-		self._maid[fireMaid] = nil
+		self._maid[fireMaid :: any] = nil
 	end)
-	self._maid[fireMaid] = fireMaid
+	self._maid[fireMaid :: any] = fireMaid
 	fireMaid:GiveTask(function()
-		self._maid[fireMaid] = nil
+		self._maid[fireMaid :: any] = nil
 	end)
 
 	-- TODO: Warn if remote event doesn't exist
@@ -473,7 +563,7 @@ end
 	@param ... any
 	@return any
 ]=]
-function Remoting:InvokeServer(memberName, ...)
+function Remoting.InvokeServer(self: Remoting, memberName: string, ...): ...any
 	assert(type(memberName) == "string", "Bad memberName")
 
 	return self:PromiseInvokeServer(memberName, ...):Wait()
@@ -485,9 +575,9 @@ end
 	@client
 	@param memberName string
 	@param ... any
-	@return Promise<any>
+	@return Promise<...any>
 ]=]
-function Remoting:PromiseInvokeServer(memberName, ...)
+function Remoting.PromiseInvokeServer(self: Remoting, memberName: string, ...): Promise.Promise<...any>
 	assert(type(memberName) == "string", "Bad memberName")
 
 	local invokeMaid = Maid.new()
@@ -497,21 +587,28 @@ function Remoting:PromiseInvokeServer(memberName, ...)
 	if self._useDummyObject then
 		promise = self:_promiseRemoteFunction(invokeMaid, self:_getDummyMemberName(memberName, "OnServerInvoke"))
 			:Then(function(remoteFunction)
-				return invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeBindableFunction(remoteFunction, Players.LocalPlayer, table.unpack(args, 1, args.n)))
+				return invokeMaid:GivePromise(
+					RemoteFunctionUtils.promiseInvokeBindableFunction(
+						remoteFunction,
+						Players.LocalPlayer,
+						table.unpack(args, 1, args.n)
+					)
+				)
 			end)
 	else
-		promise = self:_promiseRemoteFunction(invokeMaid, memberName)
-			:Then(function(remoteFunction)
-				return invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeServer(remoteFunction, table.unpack(args, 1, args.n)))
-			end)
+		promise = self:_promiseRemoteFunction(invokeMaid, memberName):Then(function(remoteFunction)
+			return invokeMaid:GivePromise(
+				RemoteFunctionUtils.promiseInvokeServer(remoteFunction, table.unpack(args, 1, args.n))
+			)
+		end)
 	end
 
 	promise:Finally(function()
-		self._maid[invokeMaid] = nil
+		self._maid[invokeMaid :: any] = nil
 	end)
-	self._maid[invokeMaid] = invokeMaid
+	self._maid[invokeMaid :: any] = invokeMaid
 	invokeMaid:GiveTask(function()
-		self._maid[invokeMaid] = nil
+		self._maid[invokeMaid :: any] = nil
 	end)
 
 	-- TODO: Warn if remote function doesn't exist
@@ -528,55 +625,57 @@ end
 	@param ... any
 	@return Promise<any>
 ]=]
-function Remoting:PromiseInvokeClient(memberName, player, ...)
+function Remoting.PromiseInvokeClient(self: Remoting, memberName: string, player: Player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
-	local invokeMaid = Maid.new()
+	local invokeMaid: Maid.Maid = Maid.new()
 
 	local promise
 	if self._useDummyObject then
-		local bindableFunction = self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke"))
+		local bindableFunction: BindableFunction =
+			self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke")) :: any
 		promise = invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeBindableFunction(bindableFunction, ...))
 	else
-		local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+		local remoteFunction: RemoteFunction = self:_getOrCreateRemoteFunction(memberName) :: any
 		promise = invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeClient(remoteFunction, player, ...))
 	end
 
 	promise:Finally(function()
-		self._maid[invokeMaid] = nil
+		self._maid[invokeMaid :: any] = nil
 	end)
 
-	self._maid[invokeMaid] = invokeMaid
+	self._maid[invokeMaid :: any] = invokeMaid
 	invokeMaid:GiveTask(function()
-		self._maid[invokeMaid] = nil
+		self._maid[invokeMaid :: any] = nil
 	end)
 
 	return promise
 end
 
-function Remoting:GetContainerClass()
+function Remoting.GetContainerClass(_self: Remoting): string
 	return "Configuration"
 end
 
-function Remoting:_ensureContainer()
+function Remoting._ensureContainer(self: Remoting): Folder
 	assert(self._remotingRealm == RemotingRealms.SERVER, "Folder should only be created on server")
 
 	if self._container then
 		return self._container
 	end
 
-	self._container = Instance.new(self:GetContainerClass())
-	self._container.Name = self._remoteFolderName
-	self._container.Archivable = false
-	self._container.Parent = self._instance
+	local created: Folder = self._maid:Add(Instance.new(self:GetContainerClass())) :: any
+	created.Name = self._remoteFolderName
+	created.Archivable = false
+	created.Parent = self._instance
 
-	self._maid:GiveTask(self._container)
+	self._maid:GiveTask(created)
+	self._container = created
 
-	return self._container
+	return created
 end
 
-function Remoting:_observeRemoteFunctionBrio(memberName)
+function Remoting._observeRemoteFunctionBrio(self: Remoting, memberName: string)
 	assert(type(memberName) == "string", "Bad memberName")
 
 	local remoteFunctionName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
@@ -588,11 +687,11 @@ function Remoting:_observeRemoteFunctionBrio(memberName)
 			else
 				return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteFunction", remoteFunctionName)
 			end
-		end)
+		end),
 	})
 end
 
-function Remoting:_observeRemoteEventBrio(memberName)
+function Remoting._observeRemoteEventBrio(self: Remoting, memberName: string)
 	assert(type(memberName) == "string", "Bad memberName")
 
 	local remoteFunctionName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
@@ -604,48 +703,54 @@ function Remoting:_observeRemoteEventBrio(memberName)
 			else
 				return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteEvent", remoteFunctionName)
 			end
-		end)
+		end),
 	})
 end
 
-function Remoting:_promiseContainer(maid)
+function Remoting._promiseContainer(self: Remoting, maid: Maid.Maid): Promise.Promise<Folder>
 	return maid:GivePromise(promiseChild(self._instance, self._remoteFolderName, 5))
 end
 
-function Remoting:_promiseRemoteEvent(maid, memberName)
+function Remoting._promiseRemoteEvent(self: Remoting, maid: Maid.Maid, memberName: string): Promise.Promise<RemoteEvent>
 	local remoteEventName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
-	return self:_promiseContainer(maid)
-		:Then(function(container)
-			return maid:GivePromise(promiseChild(container, remoteEventName, 5))
-		end)
+	return self:_promiseContainer(maid):Then(function(container)
+		return maid:GivePromise(promiseChild(container, remoteEventName, 5))
+	end)
 end
 
-function Remoting:_promiseRemoteFunction(maid, memberName)
+function Remoting._promiseRemoteFunction(
+	self: Remoting,
+	maid: Maid.Maid,
+	memberName: string
+): Promise.Promise<RemoteFunction>
 	local remoteEventName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
-	return self:_promiseContainer(maid)
-		:Then(function(container)
-			return maid:GivePromise(promiseChild(container, remoteEventName, 5))
-		end)
+	return self:_promiseContainer(maid):Then(function(container)
+		return maid:GivePromise(promiseChild(container, remoteEventName, 5))
+	end)
 end
 
-function Remoting:_observeFolderBrio()
+function Remoting._observeFolderBrio(self: Remoting): _Observable.Observable<_Brio.Brio<Folder>>
 	assert(self._instance, "Not initialized")
 
-	return RxInstanceUtils.observeLastNamedChildBrio(self._instance, self:GetContainerClass(), self._remoteFolderName)
+	return RxInstanceUtils.observeLastNamedChildBrio(
+			self._instance,
+			self:GetContainerClass(),
+			self._remoteFolderName
+		) :: any
 end
 
-function Remoting:_getOrCreateRemoteFunction(memberName)
+function Remoting._getOrCreateRemoteFunction(self: Remoting, memberName: string): RemoteFunction | BindableFunction
 	assert(type(memberName) == "string", "Bad memberName")
 
 	local remoteFunctionName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
 
 	if self._remoteObjects[remoteFunctionName] then
-		return self._remoteObjects[remoteFunctionName]
+		return self._remoteObjects[remoteFunctionName] :: any
 	end
 
 	local container = self:_ensureContainer()
 
-	local remoteFunction
+	local remoteFunction: Instance
 	if self._useDummyObject then
 		remoteFunction = Instance.new("BindableFunction")
 	else
@@ -656,24 +761,24 @@ function Remoting:_getOrCreateRemoteFunction(memberName)
 	remoteFunction.Archivable = false
 	remoteFunction.Parent = container
 
-	self._remoteObjects[remoteFunctionName] = remoteFunction
+	self._remoteObjects[remoteFunctionName] = remoteFunction :: any
 	self._maid[remoteFunction] = remoteFunction
 
-	return remoteFunction
+	return remoteFunction :: any
 end
 
-function Remoting:_getOrCreateRemoteEvent(memberName)
+function Remoting._getOrCreateRemoteEvent(self: Remoting, memberName: string): RemoteEvent | BindableEvent
 	assert(type(memberName) == "string", "Bad memberName")
 
 	local remoteEventName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
 
 	if self._remoteObjects[remoteEventName] then
-		return self._remoteObjects[remoteEventName]
+		return self._remoteObjects[remoteEventName] :: any
 	end
 
 	local container = self:_ensureContainer()
 
-	local remoteEvent
+	local remoteEvent: Instance
 	if self._useDummyObject then
 		remoteEvent = Instance.new("BindableEvent")
 	else
@@ -685,31 +790,31 @@ function Remoting:_getOrCreateRemoteEvent(memberName)
 	remoteEvent.Parent = container
 
 	self._maid[remoteEvent] = remoteEvent
-	self._remoteObjects[remoteEventName] = remoteEvent
+	self._remoteObjects[remoteEventName] = remoteEvent :: any
 
-	return remoteEvent
+	return remoteEvent :: any
 end
 
-function Remoting:_getMemberName(memberName, objectType)
+function Remoting._getMemberName(_self: Remoting, memberName: string, objectType: string): string
 	return memberName .. objectType
 end
 
-function Remoting:_getDummyMemberName(memberName, suffix)
+function Remoting._getDummyMemberName(self: Remoting, memberName: string, suffix: string): string
 	assert(self._useDummyObject, "Not dummy mode")
 
 	return memberName .. "_" .. suffix .. "_"
 end
 
-function Remoting:_getDebugMemberName(memberName)
+function Remoting._getDebugMemberName(self: Remoting, memberName: string): string
 	return string.format("%s.%s", self._name, memberName)
 end
 
 --[=[
 	Cleans up the remoting object
 ]=]
-function Remoting:Destroy()
+function Remoting.Destroy(self: Remoting)
 	self._maid:DoCleaning()
-	setmetatable(self, nil)
+	setmetatable(self :: any, nil)
 end
 
 return Remoting

package/src/Shared/Interface/RemotingMember.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Helper class for the [Remoting] object which allows more natural syntax
 	to be used against the remoting API surface.
@@ -13,6 +14,8 @@ local RemotingMember = {}
 RemotingMember.ClassName = "RemotingMember"
 RemotingMember.__index = RemotingMember
 
+export type RemotingMember = typeof(setmetatable({}, RemotingMember))
+
 --[=[
 	Constructs a new RemotingMember
 
@@ -21,7 +24,7 @@ RemotingMember.__index = RemotingMember
 	@param remotingRealm RemotingRealms
 	@return RemotingMember
 ]=]
-function RemotingMember.new(remoting, memberName, remotingRealm)
+function RemotingMember.new(remoting, memberName: string, remotingRealm: RemotingRealms.RemotingRealm): RemotingMember
 	local self = setmetatable({}, RemotingMember)
 
 	self._remoting = assert(remoting, "No remoting")
@@ -40,7 +43,7 @@ end
 	@param callback function
 	@return MaidTask
 ]=]
-function RemotingMember:Bind(callback)
+function RemotingMember:Bind(callback: (...any) -> ...any)
 	assert(type(callback) == "function", "Bad callback")
 
 	return self._remoting:Bind(self._memberName, callback)
@@ -57,7 +60,7 @@ end
 	@param callback function
 	@return MaidTask
 ]=]
-function RemotingMember:Connect(callback)
+function RemotingMember:Connect(callback: (...any) -> ())
 	assert(type(callback) == "function", "Bad callback")
 
 	return self._remoting:Connect(self._memberName, callback)
@@ -125,7 +128,6 @@ function RemotingMember:PromiseFireServer(...)
 	return self._remoting:PromiseFireServer(self._memberName, ...)
 end
 
-
 --[=[
 	Invokes the client from the server.
 
@@ -136,7 +138,7 @@ end
 	@param ... any
 	@return Promise<any>
 ]=]
-function RemotingMember:PromiseInvokeClient(player, ...)
+function RemotingMember:PromiseInvokeClient(player: Player, ...)
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(self._remotingRealm == RemotingRealms.SERVER, "PromiseInvokeClient must be called on client")
 
@@ -182,8 +184,11 @@ end
 	@param excludePlayer Player | nil
 	@param ... any
 ]=]
-function RemotingMember:FireAllClientsExcept(excludePlayer, ...)
-	assert(typeof(excludePlayer) == "Instance" and excludePlayer:IsA("Player") or excludePlayer == nil, "Bad excludePlayer")
+function RemotingMember:FireAllClientsExcept(excludePlayer: Player, ...)
+	assert(
+		typeof(excludePlayer) == "Instance" and excludePlayer:IsA("Player") or excludePlayer == nil,
+		"Bad excludePlayer"
+	)
 	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClientsExcept must be called on server")
 
 	self._remoting:FireAllClientsExcept(self._memberName, excludePlayer, ...)
@@ -198,7 +203,7 @@ end
 	@param player Instance
 	@param ... any
 ]=]
-function RemotingMember:FireClient(player, ...)
+function RemotingMember:FireClient(player: Player, ...)
 	assert(self._remotingRealm == RemotingRealms.SERVER, "FireClient must be called on client")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 

package/src/Shared/Realm/RemotingRealmUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class RemotingRealmUtils
 ]=]
@@ -10,11 +11,11 @@ local RemotingRealms = require("RemotingRealms")
 
 local RemotingRealmUtils = {}
 
-function RemotingRealmUtils.isRemotingRealm(realm)
+function RemotingRealmUtils.isRemotingRealm(realm: any): boolean
 	return realm == RemotingRealms.SERVER or realm == RemotingRealms.CLIENT
 end
 
-function RemotingRealmUtils.inferRemotingRealm()
+function RemotingRealmUtils.inferRemotingRealm(): RemotingRealms.RemotingRealm
 	if RunService:IsServer() then
 		return RemotingRealms.SERVER
 	elseif RunService:IsClient() then

package/src/Shared/Realm/RemotingRealms.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class RemotingRealms
 ]=]
@@ -6,7 +7,14 @@ local require = require(script.Parent.loader).load(script)
 
 local Table = require("Table")
 
+export type RemotingRealm = "server" | "client"
+
+export type RemotingRealms = {
+	SERVER: "server",
+	CLIENT: "client",
+}
+
 return Table.readonly({
-	SERVER = "server";
-	CLIENT = "client";
-})
+	SERVER = "server",
+	CLIENT = "client",
+} :: RemotingRealms)

package/src/Shared/ResourceConstants.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Holds constants for resource retrieval.
 	@class ResourceConstants