Generics

Flux exports two generic types. Casting your event objects to them gives you argument checking, return-value checking and autocomplete on both ends.

export type Server<Args... = (...any), Out... = (...any)> = { ... }
export type Client<Args... = (...any), Out... = (...any)> = { ... }

type pack

default:"(...any)"

The arguments carried by the event, which is what you pass to Fire and what your Connect callback receives.

type pack

default:"(...any)"

The values returned by an invocation: what OnInvoke returns on the server and what Invoke yields on the client.

Both default to (...any), which is why untyped Flux code compiles cleanly but gives you no autocomplete.

Typing an event

local myEvent = Flux.Server("MyEvent") :: Flux.Server<{ Arg: string }>

myEvent:Fire(player, { Arg = "Hello World" })
myEvent:FireAll({ Arg = "Broadcast" })

local myEvent = Flux.Client("MyEvent") :: Flux.Client<{ Arg: string }>

myEvent:Connect(function(data)
	print(data.Arg) --> "Hello World"
end)

Because Args... is a type pack, multiple arguments work exactly as you would expect:

local Damage = Flux.Server("Damage") :: Flux.Server<(Instance, number)>

Damage:FireAll(humanoid, 250)
Damage:FireAll(humanoid)       -- analysis error: missing argument
Damage:FireAll(humanoid, "hi") -- analysis error: string ~= number

Wrap a multi-value pack in parentheses, as in <(Instance, number)>. A single type needs no parentheses, as in <{ Arg: string }>. Without them, <Instance, number> is parsed as Args... = Instance and Out... = number.

Typing an invocation

The second parameter types the return values.

local myInvokeEvent = Flux.Server("MyInvokeEvent") :: Flux.Server<(), (boolean, string)>

myInvokeEvent.OnInvoke = function(player)
	return true, "Success!"
end

local myInvokeEvent = Flux.Client("MyInvokeEvent") :: Flux.Client<(), (boolean, string)>

local success, message = myInvokeEvent:Invoke()
--    ^ boolean  ^ string

Use () for the empty pack when an event takes no arguments but does return values.

Arguments and returns together

-- Takes a string, returns (boolean, number).
type PurchaseServer = Flux.Server<(string), (boolean, number)>
type PurchaseClient = Flux.Client<(string), (boolean, number)>

-- Server
local Shop = Flux.Server("Shop") :: PurchaseServer
Shop.OnInvoke = function(player, itemId)
	return true, priceOf(itemId)
end

-- Client
local Shop = Flux.Client("Shop") :: PurchaseClient
local ok, price = Shop:Invoke("sword")

Declaring the pack once in a shared module keeps the two ends from drifting apart. It is the same problem schemas have, solved the same way.

local Flux = require(game:GetService("ReplicatedStorage").Flux)

export type MoveArgs = (Instance, Vector3, number)
export type PurchaseArgs = (string)
export type PurchaseOut = (boolean, number)

export type MoveServer = Flux.Server<MoveArgs>
export type MoveClient = Flux.Client<MoveArgs>
export type PurchaseServer = Flux.Server<PurchaseArgs, PurchaseOut>
export type PurchaseClient = Flux.Client<PurchaseArgs, PurchaseOut>

return {}

local NetTypes = require(ReplicatedStorage.NetTypes)

local Move = Flux.Server("Move") :: NetTypes.MoveServer
local Shop = Flux.Server("Shop") :: NetTypes.PurchaseServer

local NetTypes = require(ReplicatedStorage.NetTypes)

local Move = Flux.Client("Move") :: NetTypes.MoveClient
local Shop = Flux.Client("Shop") :: NetTypes.PurchaseClient

What generics do and do not do

Generics are a compile-time cast, enforced only by Luau’s type checker. They do not validate anything at runtime.A client that has been tampered with can send any payload it likes, and your typed Connect callback will happily receive it. Every server listener still has to validate its inputs, checking types, clamping ranges and verifying ownership, exactly as you would with a raw RemoteEvent.

Generics and schemas are independent and complementary. Generics constrain what your Luau code may pass; schemas constrain what goes on the wire. Neither implies the other, and a mismatch between them is not reported. A Flux.Server<(string)> with a { T.UInt8() } schema type-checks fine and fails at runtime.

Getting Started

Guides

Concepts

Reference

Typing an event

Typing an invocation

Arguments and returns together

What generics do and do not do

Next steps

Server type

Client type

​Typing an event

​Typing an invocation

​Arguments and returns together

​Sharing type definitions

​What generics do and do not do

​Next steps

Server type

Client type

Typing an event

Typing an invocation

Arguments and returns together

Sharing type definitions

What generics do and do not do

Next steps