-- Compiled with roblox-ts v2.0.4
local TS = _G[script]
local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
local Players = _services.Players
local RunService = _services.RunService
--[[
	*
	* NetEvent type.
]]
local NetEventType
do
	local _inverse = {}
	NetEventType = setmetatable({}, {
		__index = _inverse,
	})
	NetEventType.TwoWay = 0
	_inverse[0] = "TwoWay"
	NetEventType.ServerToClient = 1
	_inverse[1] = "ServerToClient"
	NetEventType.ClientToServer = 2
	_inverse[2] = "ClientToServer"
end
local function awaitSeedAttr()
	local seed = script:GetAttribute("s")
	while seed == nil do
		task.wait()
		seed = script:GetAttribute("s")
	end
	script:SetAttribute("s", nil)
	return seed
end
local seed = if RunService:IsServer() then DateTime.now().UnixTimestamp else awaitSeedAttr()
local netFolder
if RunService:IsServer() then
	netFolder = Instance.new("Folder")
	netFolder.Name = "ProtonNet"
	netFolder.Parent = script
	script:SetAttribute("s", seed)
else
	netFolder = script:WaitForChild("ProtonNet")
end
local networkNames = {}
local function generateNetworkName(data)
	local _data = data
	local _arg1 = #data
	local _exp = { string.byte(_data, 1, _arg1) }
	local _arg0 = function(accumulator, val)
		return accumulator + val
	end
	-- ▼ ReadonlyArray.reduce ▼
	if #_exp == 0 then
		error("Attempted to call `ReadonlyArray.reduce()` on an empty array without an initialValue.")
	end
	local _result = _exp[1]
	local _callback = _arg0
	for _i = 2, #_exp do
		_result = _callback(_result, _exp[_i], _i - 1, _exp)
	end
	-- ▲ ReadonlyArray.reduce ▲
	local sum = _result
	local nameSeed = seed + sum
	local rng = Random.new(nameSeed)
	local nameArray = {}
	do
		local i = 0
		local _shouldIncrement = false
		while true do
			if _shouldIncrement then
				i += 1
			else
				_shouldIncrement = true
			end
			if not (i < 16) then
				break
			end
			local _arg0_1 = rng:NextInteger(33, 126)
			table.insert(nameArray, _arg0_1)
		end
	end
	local iter = 0
	local baseName = string.char(unpack(nameArray))
	local name = baseName
	while true do
		local _name = name
		if not (networkNames[_name] ~= nil) then
			break
		end
		name = baseName .. tostring(iter)
		iter += 1
	end
	local _name = name
	networkNames[_name] = true
	return name
end
local function setupRemoteObject(className, name)
	if name == nil or not RunService:IsStudio() then
		local s, l = debug.info(2, "sl")
		name = generateNetworkName(s .. tostring(l))
	end
	name = "r/" .. name
	local remote
	if RunService:IsServer() then
		remote = Instance.new(className)
		remote.Name = name
		remote.Parent = netFolder
	else
		remote = netFolder:WaitForChild(name)
	end
	return remote
end
local NetEventClient
do
	NetEventClient = setmetatable({}, {
		__tostring = function()
			return "NetEventClient"
		end,
	})
	NetEventClient.__index = NetEventClient
	function NetEventClient.new(...)
		local self = setmetatable({}, NetEventClient)
		return self:constructor(...) or self
	end
	function NetEventClient:constructor(re)
		self.re = re
	end
	function NetEventClient:fire(...)
		local args = { ... }
		self.re:FireServer(unpack(args))
	end
	function NetEventClient:connect(handler)
		return self.re.OnClientEvent:Connect(handler)
	end
end
local NetEventServer
do
	NetEventServer = setmetatable({}, {
		__tostring = function()
			return "NetEventServer"
		end,
	})
	NetEventServer.__index = NetEventServer
	function NetEventServer.new(...)
		local self = setmetatable({}, NetEventServer)
		return self:constructor(...) or self
	end
	function NetEventServer:constructor(re)
		self.re = re
	end
	function NetEventServer:fireAll(...)
		local args = { ... }
		self.re:FireAllClients(unpack(args))
	end
	function NetEventServer:fire(player, ...)
		local args = { ... }
		local _player = player
		if typeof(_player) == "table" then
			for _, plr in player do
				self.re:FireClient(plr, unpack(args))
			end
		else
			self.re:FireClient(player, unpack(args))
		end
	end
	function NetEventServer:fireExcept(exceptPlayer, ...)
		local args = { ... }
		local _exceptPlayer = exceptPlayer
		if typeof(_exceptPlayer) == "table" then
			for _, player in Players:GetPlayers() do
				if table.find(exceptPlayer, player) ~= nil then
					continue
				end
				self.re:FireClient(player, unpack(args))
			end
		else
			for _, player in Players:GetPlayers() do
				if player == exceptPlayer then
					continue
				end
				self.re:FireClient(player, unpack(args))
			end
		end
	end
	function NetEventServer:fireIf(predicate, ...)
		local args = { ... }
		for _, player in Players:GetPlayers() do
			if not predicate(player) then
				continue
			end
			self.re:FireClient(player, unpack(args))
		end
	end
	function NetEventServer:connect(handler)
		return self.re.OnServerEvent:Connect(handler)
	end
end
local NetFunctionServer
do
	NetFunctionServer = setmetatable({}, {
		__tostring = function()
			return "NetFunctionServer"
		end,
	})
	NetFunctionServer.__index = NetFunctionServer
	function NetFunctionServer.new(...)
		local self = setmetatable({}, NetFunctionServer)
		return self:constructor(...) or self
	end
	function NetFunctionServer:constructor(rf)
		self.rf = rf
	end
	function NetFunctionServer:handle(handler)
		self.rf.OnServerInvoke = handler
	end
end
local NetFunctionClient
do
	NetFunctionClient = setmetatable({}, {
		__tostring = function()
			return "NetFunctionClient"
		end,
	})
	NetFunctionClient.__index = NetFunctionClient
	function NetFunctionClient.new(...)
		local self = setmetatable({}, NetFunctionClient)
		return self:constructor(...) or self
	end
	function NetFunctionClient:constructor(rf)
		self.rf = rf
	end
	NetFunctionClient.invoke = TS.async(function(self, ...)
		local args = { ... }
		return self.rf:InvokeServer(unpack(args))
	end)
end
--[[
	*
	* NetEvent represents a RemoteEvent.
	*
	* ```ts
	* export const MyEvent = new NetEvent<[message: string]>();
	* ```
]]
local NetEvent
do
	NetEvent = setmetatable({}, {
		__tostring = function()
			return "NetEvent"
		end,
	})
	NetEvent.__index = NetEvent
	function NetEvent.new(...)
		local self = setmetatable({}, NetEvent)
		return self:constructor(...) or self
	end
	function NetEvent:constructor(name)
		self.re = setupRemoteObject("RemoteEvent", name)
		self.client = NetEventClient.new(self.re)
		self.server = NetEventServer.new(self.re)
	end
end
--[[
	*
	* NetFunction represents a RemoteFunction.
	*
	* ```ts
	* export const MyFunc = new NetFunction<void, [message: string]>();
	* ```
]]
local NetFunction
do
	NetFunction = setmetatable({}, {
		__tostring = function()
			return "NetFunction"
		end,
	})
	NetFunction.__index = NetFunction
	function NetFunction.new(...)
		local self = setmetatable({}, NetFunction)
		return self:constructor(...) or self
	end
	function NetFunction:constructor(name)
		self.rf = setupRemoteObject("RemoteFunction", name)
		self.server = NetFunctionServer.new(self.rf)
		self.client = NetFunctionClient.new(self.rf)
	end
end
return {
	NetEventType = NetEventType,
	NetEvent = NetEvent,
	NetFunction = NetFunction,
}