@quenty/permissionprovider 14.19.2 → 14.19.3

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [14.19.3](https://github.com/Quenty/NevermoreEngine/compare/@quenty/permissionprovider@14.19.2...@quenty/permissionprovider@14.19.3) (2025-04-10)
+
+**Note:** Version bump only for package @quenty/permissionprovider
+
+
+
+
+
 ## [14.19.2](https://github.com/Quenty/NevermoreEngine/compare/@quenty/permissionprovider@14.19.0...@quenty/permissionprovider@14.19.2) (2025-04-07)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/permissionprovider",
-  "version": "14.19.2",
+  "version": "14.19.3",
   "description": "Permission provider for Roblox, including authenticating against group membership",
   "keywords": [
     "Roblox",
@@ -25,20 +25,20 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "^10.8.2",
-    "@quenty/brio": "^14.17.2",
-    "@quenty/grouputils": "^10.10.3",
-    "@quenty/loader": "^10.8.2",
-    "@quenty/maid": "^3.4.2",
-    "@quenty/playerutils": "^8.17.2",
-    "@quenty/promise": "^10.10.3",
-    "@quenty/remoting": "^12.18.2",
-    "@quenty/rx": "^13.17.2",
-    "@quenty/servicebag": "^11.11.3",
-    "@quenty/table": "^3.7.3"
+    "@quenty/baseobject": "^10.8.3",
+    "@quenty/brio": "^14.17.3",
+    "@quenty/grouputils": "^10.10.4",
+    "@quenty/loader": "^10.8.3",
+    "@quenty/maid": "^3.4.3",
+    "@quenty/playerutils": "^8.17.3",
+    "@quenty/promise": "^10.10.4",
+    "@quenty/remoting": "^12.18.3",
+    "@quenty/rx": "^13.17.3",
+    "@quenty/servicebag": "^11.11.4",
+    "@quenty/table": "^3.7.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "64def70499ec067077ee39f279936b620b217847"
+  "gitHead": "b06c070ae91d5dab7bd8de6e290ad2caabb15d8f"
 }

package/src/Client/Providers/PermissionProviderClient.lua

@@ -17,8 +17,17 @@ local PermissionProviderClient = {}
 PermissionProviderClient.__index = PermissionProviderClient
 PermissionProviderClient.ClassName = "PermissionProviderClient"
 
-function PermissionProviderClient.new(remoteFunctionName)
-	local self = setmetatable({}, PermissionProviderClient)
+export type PermissionProviderClient = typeof(setmetatable(
+	{} :: {
+		_remoteFunctionName: string,
+		_remoteFunctionPromise: Promise.Promise<RemoteFunction>?,
+		_cachedAdminPromise: Promise.Promise<boolean>?,
+	},
+	{} :: typeof({ __index = PermissionProviderClient })
+))
+
+function PermissionProviderClient.new(remoteFunctionName: string): PermissionProviderClient
+	local self: PermissionProviderClient = setmetatable({} :: any, PermissionProviderClient)
 
 	self._remoteFunctionName = remoteFunctionName or PermissionProviderConstants.DEFAULT_REMOTE_FUNCTION_NAME
 
@@ -31,7 +40,10 @@ end
 	@param player Player | nil
 	@return Promise<boolean>
 ]=]
-function PermissionProviderClient:PromiseIsAdmin(player)
+function PermissionProviderClient.PromiseIsAdmin(
+	self: PermissionProviderClient,
+	player: Player?
+): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player") or player == nil, "Bad player")
 
 	if player ~= nil then
@@ -46,29 +58,28 @@ function PermissionProviderClient:PromiseIsAdmin(player)
 		return self._cachedAdminPromise
 	end
 
-	self._cachedAdminPromise = self:_promiseRemoteFunction()
-		:Then(function(remoteFunction)
-			return Promise.spawn(function(resolve, reject)
-				local result = nil
-				local ok, err = pcall(function()
-					result = remoteFunction:InvokeServer()
-				end)
-				if not ok then
-					return reject(err)
-				end
-
-				if type(result) ~= "boolean" then
-					return reject("Got non-boolean from server")
-				end
-
-				return resolve(result)
+	self._cachedAdminPromise = self:_promiseRemoteFunction():Then(function(remoteFunction)
+		return Promise.spawn(function(resolve, reject)
+			local result = nil
+			local ok, err = pcall(function()
+				result = remoteFunction:InvokeServer()
 			end)
+			if not ok then
+				return reject(err)
+			end
+
+			if type(result) ~= "boolean" then
+				return reject("Got non-boolean from server")
+			end
+
+			return resolve(result)
 		end)
+	end)
 
-	return self._cachedAdminPromise
+	return self._cachedAdminPromise :: any
 end
 
-function PermissionProviderClient:_promiseRemoteFunction()
+function PermissionProviderClient._promiseRemoteFunction(self: PermissionProviderClient)
 	if self._remoteFunctionPromise then
 		return self._remoteFunctionPromise
 	end

package/src/Server/PermissionProviderUtils.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Utility functions to provide/configure a permission. See [BasePermissionProvider] and [PermissionService].
 
@@ -11,22 +12,44 @@ local PermissionProviderConstants = require("PermissionProviderConstants")
 
 local PermissionProviderUtils = {}
 
+type GroupRankConfig_Input = {
+	groupId: number,
+	minAdminRequiredRank: number,
+	minCreatorRequiredRank: number,
+	remoteFunctionName: string?,
+}
+
+export type GroupRankConfig = {
+	type: "GroupRankConfigType",
+} & GroupRankConfig_Input
+
+export type SingleUserConfig_Input = {
+	userId: number,
+	remoteFunctionName: string?,
+}
+
+export type SingleUserConfig = {
+	type: "SingleUserConfigType",
+} & SingleUserConfig_Input
+
+export type PermissionProviderConfig = GroupRankConfig | SingleUserConfig
+
 --[=[
 	Creates a group rank config
 	@param config { groupId: number, minAdminRequiredRank: number, minCreatorRequiredRank: number }
 	@return table
 ]=]
-function PermissionProviderUtils.createGroupRankConfig(config)
+function PermissionProviderUtils.createGroupRankConfig(config: GroupRankConfig_Input): GroupRankConfig
 	assert(type(config.groupId) == "number", "Bad groupId")
 	assert(type(config.minCreatorRequiredRank) == "number", "Bad minCreatorRequiredRank")
 	assert(type(config.minAdminRequiredRank) == "number", "Bad minAdminRequiredRank")
 
 	return {
-		type = PermissionProviderConstants.GROUP_RANK_CONFIG_TYPE;
-		groupId = config.groupId;
-		minAdminRequiredRank = config.minAdminRequiredRank;
-		minCreatorRequiredRank = config.minCreatorRequiredRank;
-		remoteFunctionName = config.remoteFunctionName or PermissionProviderConstants.DEFAULT_REMOTE_FUNCTION_NAME;
+		type = PermissionProviderConstants.GROUP_RANK_CONFIG_TYPE,
+		groupId = config.groupId,
+		minAdminRequiredRank = config.minAdminRequiredRank,
+		minCreatorRequiredRank = config.minCreatorRequiredRank,
+		remoteFunctionName = config.remoteFunctionName or PermissionProviderConstants.DEFAULT_REMOTE_FUNCTION_NAME,
 	}
 end
 
@@ -35,13 +58,13 @@ end
 	@param config { userId: number }
 	@return table
 ]=]
-function PermissionProviderUtils.createSingleUserConfig(config)
+function PermissionProviderUtils.createSingleUserConfig(config: SingleUserConfig_Input): SingleUserConfig
 	assert(type(config.userId) == "number", "Bad userId")
 
 	return {
-		type = PermissionProviderConstants.SINGLE_USER_CONFIG_TYPE;
-		userId = config.userId;
-		remoteFunctionName = config.remoteFunctionName or PermissionProviderConstants.DEFAULT_REMOTE_FUNCTION_NAME;
+		type = PermissionProviderConstants.SINGLE_USER_CONFIG_TYPE,
+		userId = config.userId,
+		remoteFunctionName = config.remoteFunctionName or PermissionProviderConstants.DEFAULT_REMOTE_FUNCTION_NAME,
 	}
 end
 
@@ -49,7 +72,7 @@ end
 	Creates an automatic configuration from the game.
 	@return table
 ]=]
-function PermissionProviderUtils.createConfigFromGame()
+function PermissionProviderUtils.createConfigFromGame(): PermissionProviderConfig
 	if game.CreatorType == Enum.CreatorType.Group then
 		return PermissionProviderUtils.createGroupRankConfig({
 			groupId = game.CreatorId;

package/src/Server/PermissionService.lua

@@ -35,24 +35,34 @@ local Rx = require("Rx")
 local RxBrioUtils = require("RxBrioUtils")
 local RxPlayerUtils = require("RxPlayerUtils")
 local PermissionLevelUtils = require("PermissionLevelUtils")
+local _ServiceBag = require("ServiceBag")
+local _Observable = require("Observable")
+local _Brio = require("Brio")
+local _BasePermissionProvider = require("BasePermissionProvider")
 
 local PermissionService = {}
 PermissionService.ServiceName = "PermissionService"
 
+export type PermissionService = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_promise: Promise.Promise<()>,
+		_provider: any,
+	},
+	{} :: typeof({ __index = PermissionService })
+))
+
 --[=[
 	Initializes the service. Should be done via [ServiceBag].
 	@param _serviceBag ServiceBag
 ]=]
-function PermissionService:Init(_serviceBag)
+function PermissionService:Init(_serviceBag: _ServiceBag.ServiceBag)
 	assert(not self._promise, "Already initialized")
 	assert(not self._provider, "Already have provider")
 
 	self._provider = nil
-
 	self._maid = Maid.new()
-
-	self._promise = Promise.new()
-	self._maid:GiveTask(self._promise)
+	self._promise = self._maid:Add(Promise.new())
 end
 
 --[=[
@@ -61,7 +71,7 @@ end
 
 	@param config { type: string }
 ]=]
-function PermissionService:SetProviderFromConfig(config)
+function PermissionService:SetProviderFromConfig(config: PermissionProviderUtils.PermissionProviderConfig)
 	assert(self._promise, "Not initialized")
 	assert(not self._provider, "Already have provider set")
 
@@ -91,7 +101,7 @@ end
 	Returns the permission provider
 	@return Promise<BasePermissionProvider>
 ]=]
-function PermissionService:PromisePermissionProvider()
+function PermissionService:PromisePermissionProvider(): Promise.Promise<_BasePermissionProvider.BasePermissionProvider>
 	assert(self._promise, "Not initialized")
 
 	return self._promise
@@ -102,7 +112,7 @@ end
 	@param player Player
 	@return Promise<boolean>
 ]=]
-function PermissionService:PromiseIsAdmin(player: Player)
+function PermissionService:PromiseIsAdmin(player: Player): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "bad player")
 
 	return self:PromiseIsPermissionLevel(player, PermissionLevel.ADMIN)
@@ -113,7 +123,7 @@ end
 	@param player Player
 	@return Promise<boolean>
 ]=]
-function PermissionService:PromiseIsCreator(player: Player)
+function PermissionService:PromiseIsCreator(player: Player): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "bad player")
 
 	return self:PromiseIsPermissionLevel(player, PermissionLevel.CREATOR)
@@ -125,7 +135,10 @@ end
 	@param permissionLevel PermissionLevel
 	@return Promise<boolean>
 ]=]
-function PermissionService:PromiseIsPermissionLevel(player: Player, permissionLevel)
+function PermissionService:PromiseIsPermissionLevel(
+	player: Player,
+	permissionLevel: PermissionLevel.PermissionLevel
+): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "bad player")
 	assert(PermissionLevelUtils.isPermissionLevel(permissionLevel), "Bad permissionLevel")
 
@@ -140,7 +153,7 @@ end
 	@param permissionLevel PermissionLevel
 	@return Observable<Brio<Player>>
 ]=]
-function PermissionService:ObservePermissionedPlayersBrio(permissionLevel)
+function PermissionService:ObservePermissionedPlayersBrio(permissionLevel: PermissionLevel.PermissionLevel): _Observable.Observable<_Brio.Brio<Player>>
 	assert(PermissionLevelUtils.isPermissionLevel(permissionLevel), "Bad permissionLevel")
 
 	return RxPlayerUtils.observePlayersBrio():Pipe({

package/src/Server/Providers/BasePermissionProvider.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Basic interface for providing permissions.
 	@server
@@ -11,21 +12,32 @@ local GetRemoteFunction = require("GetRemoteFunction")
 local PermissionLevel = require("PermissionLevel")
 local PermissionLevelUtils = require("PermissionLevelUtils")
 local Table = require("Table")
+local _Promise = require("Promise")
+local _PermissionProviderUtils = require("PermissionProviderUtils")
 
 local BasePermissionProvider = setmetatable({}, BaseObject)
 BasePermissionProvider.ClassName = "BasePermissionProvider"
 BasePermissionProvider.__index = BasePermissionProvider
 
+export type BasePermissionProvider = typeof(setmetatable(
+	{} :: {
+		_config: { remoteFunctionName: string },
+		_remoteFunctionName: string,
+		_remoteFunction: RemoteFunction?,
+	},
+	{} :: typeof({ __index = BasePermissionProvider })
+)) & BaseObject.BaseObject
+
 --[=[
 	Initializes a new permission provider
 
 	@param config { remoteFunctionName: string }
 	@return BasePermissionProvider
 ]=]
-function BasePermissionProvider.new(config)
-	local self = setmetatable(BaseObject.new(), BasePermissionProvider)
+function BasePermissionProvider.new(config: _PermissionProviderUtils.PermissionProviderConfig): BasePermissionProvider
+	local self: BasePermissionProvider = setmetatable(BaseObject.new() :: any, BasePermissionProvider)
 
-	self._config = Table.readonly(assert(config, "Bad config"))
+	self._config = Table.readonly(assert(config, "Bad config") :: any)
 	self._remoteFunctionName = assert(self._config.remoteFunctionName, "Bad config")
 
 	return self
@@ -34,13 +46,14 @@ end
 --[=[
 	Starts the permission provider. Should be done via ServiceBag.
 ]=]
-function BasePermissionProvider:Start()
-	assert(not self._remoteFunction, "No remoteFunction")
+function BasePermissionProvider.Start(self: BasePermissionProvider): ()
+	assert(not (self :: any)._remoteFunction, "No remoteFunction")
 
-	self._remoteFunction = GetRemoteFunction(self._remoteFunctionName)
-	self._remoteFunction.OnServerInvoke = function(...)
+	local remoteFunction = GetRemoteFunction(self._remoteFunctionName)
+	remoteFunction.OnServerInvoke = function(...)
 		return self:_onServerInvoke(...)
 	end
+	self._remoteFunction = remoteFunction
 end
 
 --[=[
@@ -49,7 +62,11 @@ end
 	@param permissionLevel PermissionLevel
 	@return Promise<boolean>
 ]=]
-function BasePermissionProvider:PromiseIsPermissionLevel(player: Player, permissionLevel)
+function BasePermissionProvider.PromiseIsPermissionLevel(
+	_self: BasePermissionProvider,
+	player: Player,
+	permissionLevel: PermissionLevel.PermissionLevel
+): _Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(PermissionLevelUtils.isPermissionLevel(permissionLevel), "Bad permissionLevel")
 
@@ -62,7 +79,11 @@ end
 	@param permissionLevel PermissionLevel
 	@return Promise<boolean>
 ]=]
-function BasePermissionProvider:IsPermissionLevel(player: Player, permissionLevel): boolean
+function BasePermissionProvider.IsPermissionLevel(
+	self: BasePermissionProvider,
+	player: Player,
+	permissionLevel: PermissionLevel.PermissionLevel
+): boolean
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(PermissionLevelUtils.isPermissionLevel(permissionLevel), "Bad permissionLevel")
 
@@ -85,7 +106,10 @@ end
 	@param player Player
 	@return Promise<boolean>
 ]=]
-function BasePermissionProvider:PromiseIsCreator(player: Player)
+function BasePermissionProvider.PromiseIsCreator(
+	self: BasePermissionProvider,
+	player: Player
+): _Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
 	return self:PromiseIsPermissionLevel(player, PermissionLevel.CREATOR)
@@ -96,7 +120,7 @@ end
 	@param player Player
 	@return Promise<boolean>
 ]=]
-function BasePermissionProvider:PromiseIsAdmin(player: Player)
+function BasePermissionProvider.PromiseIsAdmin(self: BasePermissionProvider, player: Player): _Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
 	return self:PromiseIsPermissionLevel(player, PermissionLevel.ADMIN)
@@ -112,10 +136,10 @@ end
 	@param player Player
 	@return boolean
 ]=]
-function BasePermissionProvider:IsCreator(player: Player): boolean
+function BasePermissionProvider.IsCreator(self: BasePermissionProvider, player: Player): boolean
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
-	return self:IsCreator(player, PermissionLevel.CREATOR)
+	return self:IsPermissionLevel(player, PermissionLevel.CREATOR)
 end
 
 --[=[
@@ -128,13 +152,13 @@ end
 	@param player Player
 	@return boolean
 ]=]
-function BasePermissionProvider:IsAdmin(player: Player): boolean
+function BasePermissionProvider.IsAdmin(self: BasePermissionProvider, player: Player): boolean
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
 	return self:IsPermissionLevel(player, PermissionLevel.ADMIN)
 end
 
-function BasePermissionProvider:_onServerInvoke(player)
+function BasePermissionProvider._onServerInvoke(self: BasePermissionProvider, player: Player): boolean
 	local promise = self:PromiseIsAdmin(player)
 	local ok, result = promise:Yield()
 	if not ok then
@@ -145,5 +169,4 @@ function BasePermissionProvider:_onServerInvoke(player)
 	return result and true or false
 end
 
-
 return BasePermissionProvider

package/src/Server/Providers/CreatorPermissionProvider.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Provides permissions from a single user creator
 
@@ -14,17 +15,27 @@ local PermissionProviderConstants = require("PermissionProviderConstants")
 local Promise = require("Promise")
 local PermissionLevel = require("PermissionLevel")
 local PermissionLevelUtils = require("PermissionLevelUtils")
+local _PermissionProviderUtils = require("PermissionProviderUtils")
 
 local CreatorPermissionProvider = setmetatable({}, BasePermissionProvider)
 CreatorPermissionProvider.ClassName = "CreatorPermissionProvider"
 CreatorPermissionProvider.__index = CreatorPermissionProvider
 
+export type CreatorPermissionProvider = typeof(setmetatable(
+	{} :: {
+		_config: _PermissionProviderUtils.SingleUserConfig,
+		_userId: number,
+	},
+	{} :: typeof({ __index = CreatorPermissionProvider })
+)) & BasePermissionProvider.BasePermissionProvider
+
 --[=[
 	@param config table
 	@return CreatorPermissionProvider
 ]=]
-function CreatorPermissionProvider.new(config)
-	local self = setmetatable(BasePermissionProvider.new(config), CreatorPermissionProvider)
+function CreatorPermissionProvider.new(config: _PermissionProviderUtils.SingleUserConfig): CreatorPermissionProvider
+	local self: CreatorPermissionProvider =
+		setmetatable(BasePermissionProvider.new(config) :: any, CreatorPermissionProvider)
 
 	assert(self._config.type == PermissionProviderConstants.SINGLE_USER_CONFIG_TYPE, "Bad configType")
 	self._userId = assert(self._config.userId, "No userId")
@@ -39,7 +50,7 @@ end
 	@param permissionLevel PermissionLevel
 	@return Promise<boolean>
 ]=]
-function CreatorPermissionProvider:PromiseIsPermissionLevel(player, permissionLevel)
+function CreatorPermissionProvider.PromiseIsPermissionLevel(self: CreatorPermissionProvider, player: Player, permissionLevel: PermissionLevel.PermissionLevel): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(PermissionLevelUtils.isPermissionLevel(permissionLevel), "Bad permissionLevel")
 

package/src/Server/Providers/GroupPermissionProvider.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	Provides permissions from a group
 
@@ -15,17 +16,31 @@ local PermissionLevel = require("PermissionLevel")
 local PermissionLevelUtils = require("PermissionLevelUtils")
 local PermissionProviderConstants = require("PermissionProviderConstants")
 local Promise = require("Promise")
+local _PermissionProviderUtils = require("PermissionProviderUtils")
 
 local GroupPermissionProvider = setmetatable({}, BasePermissionProvider)
 GroupPermissionProvider.__index = GroupPermissionProvider
 GroupPermissionProvider.ClassName = "GroupPermissionProvider"
 
+export type GroupPermissionProvider = typeof(setmetatable(
+	{} :: {
+		_config: _PermissionProviderUtils.GroupRankConfig,
+		_groupId: number,
+		_minAdminRequiredRank: number,
+		_minCreatorRequiredRank: number,
+		_adminsCache: { [number]: true },
+		_creatorCache: { [number]: true },
+		_promiseRankPromisesCache: { [number]: Promise.Promise<number> },
+	},
+	{} :: typeof({ __index = GroupPermissionProvider })
+)) & BasePermissionProvider.BasePermissionProvider
+
 --[=[
 	@param config table
 	@return GroupPermissionProvider
 ]=]
-function GroupPermissionProvider.new(config)
-	local self = setmetatable(BasePermissionProvider.new(config), GroupPermissionProvider)
+function GroupPermissionProvider.new(config: _PermissionProviderUtils.GroupRankConfig): GroupPermissionProvider
+	local self = setmetatable(BasePermissionProvider.new(config) :: any, GroupPermissionProvider)
 
 	assert(self._config.type == PermissionProviderConstants.GROUP_RANK_CONFIG_TYPE, "Bad configType")
 
@@ -40,12 +55,12 @@ end
 --[=[
 	Starts the permission provider. Should be done via ServiceBag.
 ]=]
-function GroupPermissionProvider:Start()
+function GroupPermissionProvider.Start(self: GroupPermissionProvider)
 	assert(self._config, "Bad config")
 
 	getmetatable(GroupPermissionProvider).Start(self)
 
-	self._maid:GiveTask(Players.PlayerRemoving:Connect(function(player)
+	self._maid:GiveTask(Players.PlayerRemoving:Connect(function(player: Player)
 		local userId = player.UserId
 
 		self._adminsCache[userId] = nil
@@ -76,7 +91,11 @@ end
 	@param permissionLevel PermissionLevel
 	@return Promise<boolean>
 ]=]
-function GroupPermissionProvider:PromiseIsPermissionLevel(player: Player, permissionLevel)
+function GroupPermissionProvider.PromiseIsPermissionLevel(
+	self: GroupPermissionProvider,
+	player: Player,
+	permissionLevel: PermissionLevel.PermissionLevel
+): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(PermissionLevelUtils.isPermissionLevel(permissionLevel), "Bad permissionLevel")
 
@@ -89,7 +108,10 @@ function GroupPermissionProvider:PromiseIsPermissionLevel(player: Player, permis
 	end
 end
 
-function GroupPermissionProvider:_promiseIsCreator(player: Player)
+function GroupPermissionProvider._promiseIsCreator(
+	self: GroupPermissionProvider,
+	player: Player
+): Promise.Promise<boolean>
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 	assert(player:IsDescendantOf(game), "Bad player")
 
@@ -102,7 +124,10 @@ function GroupPermissionProvider:_promiseIsCreator(player: Player)
 	end)
 end
 
-function GroupPermissionProvider:_promiseIsAdmin(player: Player)
+function GroupPermissionProvider._promiseIsAdmin(
+	self: GroupPermissionProvider,
+	player: Player
+): Promise.Promise<boolean>
 	assert(player:IsDescendantOf(game))
 
 	-- really not saving much time.
@@ -119,7 +144,7 @@ function GroupPermissionProvider:_promiseIsAdmin(player: Player)
 	end)
 end
 
-function GroupPermissionProvider:_handlePlayer(player: Player)
+function GroupPermissionProvider._handlePlayer(self: GroupPermissionProvider, player: Player): ()
 	assert(player, "Bad player")
 
 	self:_promiseRankInGroup(player):Then(function(rank)
@@ -133,7 +158,7 @@ function GroupPermissionProvider:_handlePlayer(player: Player)
 	end)
 end
 
-function GroupPermissionProvider:_promiseRankInGroup(player: Player)
+function GroupPermissionProvider._promiseRankInGroup(self: GroupPermissionProvider, player: Player): Promise.Promise<number>
 	assert(typeof(player) == "Instance", "Bad player")
 
 	if self._promiseRankPromisesCache[player.UserId] then

package/src/Shared/PermissionLevel.lua

@@ -1,3 +1,4 @@
+--!strict
 --[=[
 	@class PermissionLevel
 ]=]
@@ -6,7 +7,14 @@ local require = require(script.Parent.loader).load(script)
 
 local Table = require("Table")
 
+export type PermissionLevel = "admin" | "creator"
+
+export type PermissionLevelMap = {
+	ADMIN: "admin",
+	CREATOR: "creator",
+}
+
 return Table.readonly({
-	ADMIN = "admin";
-	CREATOR = "creator";
-})
+	ADMIN = "admin",
+	CREATOR = "creator",
+} :: PermissionLevelMap)

package/src/Shared/PermissionLevelUtils.lua

@@ -13,8 +13,11 @@ for _, item in PermissionLevel do
 	ALLOWED[item] = true
 end
 
-function PermissionLevelUtils.isPermissionLevel(permissionLevel)
-	return ALLOWED[permissionLevel]
+--[=[
+	Returns true if a permission level
+]=]
+function PermissionLevelUtils.isPermissionLevel(permissionLevel: any): boolean
+	return ALLOWED[permissionLevel] == true
 end
 
 return PermissionLevelUtils

package/src/Shared/PermissionProviderConstants.lua

@@ -7,10 +7,16 @@ local require = require(script.Parent.loader).load(script)
 
 local Table = require("Table")
 
+export type PermissionProviderConstants = {
+	DEFAULT_REMOTE_FUNCTION_NAME: "PermissionProviderDefaultRemoteFunction",
+	GROUP_RANK_CONFIG_TYPE: "GroupRankConfigType",
+	SINGLE_USER_CONFIG_TYPE: "SingleUserConfigType",
+}
+
 return Table.readonly({
-	DEFAULT_REMOTE_FUNCTION_NAME = "PermissionProviderDefaultRemoteFunction";
+	DEFAULT_REMOTE_FUNCTION_NAME = "PermissionProviderDefaultRemoteFunction",
 
 	-- types
-	GROUP_RANK_CONFIG_TYPE = "GroupRankConfigType";
-	SINGLE_USER_CONFIG_TYPE = "SingleUserConfigType";
-})
+	GROUP_RANK_CONFIG_TYPE = "GroupRankConfigType",
+	SINGLE_USER_CONFIG_TYPE = "SingleUserConfigType",
+} :: PermissionProviderConstants)