-- Compiled with roblox-ts v3.0.0
local TS = _G[script]
local Signal = TS.import(script, TS.getModule(script, "@rbxts", "beacon").out).Signal
local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
local remotes = TS.import(script, script.Parent.Parent.Parent, "remotes").remotes
local _utilities = TS.import(script, script.Parent.Parent.Parent, "utilities")
local IsClient = _utilities.IsClient
local IsServer = _utilities.IsServer
local logAssert = _utilities.logAssert
local logWarning = _utilities.logWarning
local IsSharedComponentRemoteEvent = function(obj)
	return obj.Identifier ~= nil
end
local SharedRemoteEventServerToClient
do
	SharedRemoteEventServerToClient = setmetatable({}, {
		__tostring = function()
			return "SharedRemoteEventServerToClient"
		end,
	})
	SharedRemoteEventServerToClient.__index = SharedRemoteEventServerToClient
	function SharedRemoteEventServerToClient.new(...)
		local self = setmetatable({}, SharedRemoteEventServerToClient)
		return self:constructor(...) or self
	end
	function SharedRemoteEventServerToClient:constructor(guard)
		self.Identifier = SharedRemoteEventServerToClient.RemoteEventIndefinitely
		self.guard = guard
		local _condition = IsClient
		if _condition then
			self.signal = Signal.new()
			_condition = (self.signal)
		end
	end
	function SharedRemoteEventServerToClient:Indefinitely(obj)
		return obj.Identifier == SharedRemoteEventServerToClient.RemoteEventIndefinitely
	end
	function SharedRemoteEventServerToClient:send(players, ...)
		local args = { ... }
		-- ▼ ReadonlyArray.forEach ▼
		local _callback = function(player)
			remotes._shared_component_remote_event_Client:fire(player, self.componentReferense:GetID(), self.name, args)
		end
		for _k, _v in players do
			_callback(_v, _k - 1, players)
		end
		-- ▲ ReadonlyArray.forEach ▲
	end
	function SharedRemoteEventServerToClient:GetSignal()
		return self.signal
	end
	function SharedRemoteEventServerToClient:GetGuard()
		return self.guard
	end
	function SharedRemoteEventServerToClient:filterPlayersToConnect(players)
		local _players = players
		if typeof(_players) == "Instance" then
			return if self.componentReferense:IsConnectedPlayer(players) then players else nil
		end
		-- ▼ ReadonlyArray.filter ▼
		local _newValue = {}
		local _callback = function(player)
			return self.componentReferense:IsConnectedPlayer(player)
		end
		local _length = 0
		for _k, _v in players do
			if _callback(_v, _k - 1, players) == true then
				_length += 1
				_newValue[_length] = _v
			end
		end
		-- ▲ ReadonlyArray.filter ▲
		return _newValue
	end
	function SharedRemoteEventServerToClient:Fire(players, ...)
		local args = { ... }
		logAssert(IsServer, "Event can't be fired on client")
		players = self:filterPlayersToConnect(players)
		if players == nil then
			return nil
		end
		local _self = self
		local _players = players
		_self:send(if typeof(_players) == "Instance" then { players } else players, unpack(args))
	end
	function SharedRemoteEventServerToClient:Except(players, ...)
		local args = { ... }
		logAssert(IsServer, "Event can't be fired on client")
		players = self:filterPlayersToConnect(players)
		if players == nil then
			return nil
		end
		local _players = players
		local playerArray = if typeof(_players) == "Instance" then { players } else players
		local _self = self
		local _exp = Players:GetPlayers()
		-- ▼ ReadonlyArray.filter ▼
		local _newValue = {}
		local _callback = function(player)
			local _player = player
			return not (table.find(playerArray, _player) ~= nil)
		end
		local _length = 0
		for _k, _v in _exp do
			if _callback(_v, _k - 1, _exp) == true then
				_length += 1
				_newValue[_length] = _v
			end
		end
		-- ▲ ReadonlyArray.filter ▲
		_self:send(_newValue, unpack(args))
	end
	function SharedRemoteEventServerToClient:Broadcast(...)
		local args = { ... }
		logAssert(IsServer, "Event can't be fired on client")
		local players = self:filterPlayersToConnect(Players:GetPlayers())
		if not players then
			return nil
		end
		self:send(players, unpack(args))
	end
	function SharedRemoteEventServerToClient:Connect(callback)
		logAssert(IsClient, "Event can't be connected on server")
		return self.signal:Connect(function(...)
			local args = { ... }
			if not self.guard(args) then
				return nil
			end
			callback(unpack(args))
		end)
	end
	function SharedRemoteEventServerToClient:Destroy()
		local _result = self.signal
		if _result ~= nil then
			_result:Destroy()
		end
	end
	SharedRemoteEventServerToClient.RemoteEventIndefinitely = "__SHARED_COMPONENT_REMOTE_EVENT_SERVER_TO_CLIENT"
end
local SharedRemoteEventClientToServer
do
	SharedRemoteEventClientToServer = setmetatable({}, {
		__tostring = function()
			return "SharedRemoteEventClientToServer"
		end,
	})
	SharedRemoteEventClientToServer.__index = SharedRemoteEventClientToServer
	function SharedRemoteEventClientToServer.new(...)
		local self = setmetatable({}, SharedRemoteEventClientToServer)
		return self:constructor(...) or self
	end
	function SharedRemoteEventClientToServer:constructor(guard)
		self.Identifier = SharedRemoteEventClientToServer.RemoteEventIndefinitely
		self.guard = guard
		local _condition = IsServer
		if _condition then
			self.signal = Signal.new()
			_condition = (self.signal)
		end
	end
	function SharedRemoteEventClientToServer:Indefinitely(obj)
		return obj.Identifier == SharedRemoteEventClientToServer.RemoteEventIndefinitely
	end
	function SharedRemoteEventClientToServer:GetSignal()
		return self.signal
	end
	function SharedRemoteEventClientToServer:GetGuard()
		return self.guard
	end
	function SharedRemoteEventClientToServer:Fire(...)
		local args = { ... }
		logAssert(IsClient, "Event can't be fired on server")
		if not self.componentReferense:GetIsConnected() then
			logWarning(`Component with id {self.componentReferense:GenerateInfo().InstanceId} not connected`)
			return nil
		end
		remotes._shared_component_remote_event_Server:fire(self.componentReferense:GetID(), self.name, args)
	end
	function SharedRemoteEventClientToServer:Connect(callback)
		logAssert(IsServer, "Event can't be connected on client")
		return self.signal:Connect(function(player, ...)
			local args = { ... }
			if not self.guard(args) then
				return nil
			end
			callback(player, unpack(args))
		end)
	end
	function SharedRemoteEventClientToServer:Destroy()
		local _result = self.signal
		if _result ~= nil then
			_result:Destroy()
		end
	end
	SharedRemoteEventClientToServer.RemoteEventIndefinitely = "__SHARED_COMPONENT_REMOTE_EVENT_CLIENT_TO_SERVER"
end
return {
	IsSharedComponentRemoteEvent = IsSharedComponentRemoteEvent,
	SharedRemoteEventServerToClient = SharedRemoteEventServerToClient,
	SharedRemoteEventClientToServer = SharedRemoteEventClientToServer,
}