Zap

https://zap.redblox.dev
Admin
Zap is a lightning-fast networking code generator for Roblox that provides optimized bandwidth...
Tokens:13,964
Snippets:148
Trust Score:4.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Zap CLI via aftman

Source: https://zap.redblox.dev/intro/getting-started.html

Install Zap as a CLI using aftman. Requires aftman to be installed.

```bash
aftman add red-blox/zap
```

--------------------------------

### Install Zap with Aftman: aftman add red-blox/zap

Source: https://zap.redblox.dev/install.html

Use this command to install Zap via Aftman, a version manager for Roblox development tools. This is the recommended installation method.

```bash
$ aftman add red-blox/zap
```

--------------------------------

### Example Zap function (GetScore) for the Function API

Source: https://zap.redblox.dev/usage/generated-api.html

Defines an example function used in the Function API section. It is an Async call with two arguments and a u16 return type. Serves as the basis for the Call and SetCallback examples.

```zap
funct GetScore = {
call: Async,
args: (roundId: string, category: enum { HighScore, LowScore, AverageScore }),
rets: u16,
}
```

--------------------------------

### Axis-aligned CFrame examples

Source: https://zap.redblox.dev/config/types.html

Examples of axis-aligned CFrames that can be sent using the AlignedCFrame type. These rotations are valid for AlignedCFrame; non-axis-aligned CFrames will cause Zap to throw an error.

```lua
local CFrameSpecialCases = {
	CFrame.Angles(0, 0, 0),
	CFrame.Angles(0, math.rad(180), math.rad(90)),
	CFrame.Angles(0, math.rad(-90), 0),
	CFrame.Angles(math.rad(90), math.rad(-90), 0),
	CFrame.Angles(0, math.rad(90), math.rad(180)),
	-- and so on. there are 24 of these in total.
}
```

--------------------------------

### Zap IDL: Define server/client outputs and MyEvent event

Source: https://zap.redblox.dev/intro/getting-started.html

First Zap IDL example. Defines server and client output paths (ignored when not using the CLI) and an event named MyEvent.

```zap
opt server_output = "path/to/server/output.luau"
opt client_output = "path/to/client/output.luau"
event MyEvent = {
from: Server,
type: Reliable,
call: ManyAsync,
data: (Foo: u32, Bar: string),
}
```

--------------------------------

### funct Test

Source: https://zap.redblox.dev/config/functions.html

Example of a function definition with named arguments and an enum return type.

```APIDOC
## funct Test

### Description
Defines a function named Test with an async call, two arguments (Foo and Bar), and an enum return type.

### Definition
funct Test = {
  call: Async,
  args: (Foo: u8, Bar: string.utf8),
  rets: enum { Success, Fail }
}

### Fields
- **call** (Async) - Determines how the function is listened to on the server. Async functions can be listened to by one function and are called asynchronously.
- **args** (tuple) - Data sent to the server. Can be any Zap type. Parameter names and parentheses are optional.
- **rets** (enum) - Data sent back to the client. Can be any Zap type. Cannot be named.
```

--------------------------------

### Example Zap events (MyEvent, AnotherEvent) for the Event API

Source: https://zap.redblox.dev/usage/generated-api.html

Defines two events used throughout the Event API section. MyEvent is a ManyAsync server event with struct data, and AnotherEvent is a SingleAsync client event with tuple data. They serve as the basis for the listener and firing examples on this page.

```zap
event MyEvent = {
from: Server,
type: Reliable,
call: ManyAsync,
data: struct {
foo: string,
bar: u8,
}
}
event AnotherEvent = {
from: Client,
type: Reliable,
call: SingleAsync,
data: (Foo: boolean, Bar: u8)
}
```

--------------------------------

### funct MultipleRets

Source: https://zap.redblox.dev/config/functions.html

Example of a function definition with multiple return values.

```APIDOC
## funct MultipleRets

### Description
Defines a function with multiple return values: an enum and a string.

### Definition
funct MultipleRets = {
  call: Async,
  args: boolean,
  rets: (enum { Success, Fail }, string.utf8)
}

### Fields
- **call** (Async) - Async call type.
- **args** (boolean) - Single argument of type boolean.
- **rets** (tuple) - Multiple return values.
```

--------------------------------

### funct TwoUnnamedParameters

Source: https://zap.redblox.dev/config/functions.html

Example of a function definition with two unnamed parameters.

```APIDOC
## funct TwoUnnamedParameters

### Description
Defines a function with two unnamed parameters: u8 and string.utf8.

### Definition
funct TwoUnnamedParameters = {
  call: Async,
  args: (u8, string.utf8),
  rets: enum { Success, Fail }
}

### Fields
- **call** (Async) - Async call type.
- **args** (tuple) - Two unnamed parameters.
- **rets** (enum) - Return type.
```

--------------------------------

### Luau enum example for typescript_enum

Source: https://zap.redblox.dev/config/options.html

This example defines a Luau enum used to illustrate the typescript_enum option.

```text
type RoundStatus = enum { Starting, Playing, Intermission }
```

--------------------------------

### funct OneUnnamedParameter

Source: https://zap.redblox.dev/config/functions.html

Example of a function definition with a single unnamed parameter.

```APIDOC
## funct OneUnnamedParameter

### Description
Defines a function with a single unnamed parameter of type u8.

### Definition
funct OneUnnamedParameter = {
  call: Async,
  args: u8,
  rets: enum { Success, Fail }
}

### Fields
- **call** (Async) - Async call type.
- **args** (u8) - Single unnamed parameter.
- **rets** (enum) - Return type.
```

--------------------------------

### Union type example

Source: https://zap.redblox.dev/config/types.html

Defines a Union type that can be one of several types, checked at runtime. The union includes string, u32, enums, unknown, Instance.Player, and Instance. Unions are implicitly optional if they contain unknown.

```zap
type Union = (
string
| u32
| enum { "hello", "world" }
| enum "tag" { one { b: i8 }, two { c: buffer } }
| unknown
| Instance.Player
| Instance
)
```

--------------------------------

### On with Disconnect for ManyAsync events (MyEvent)

Source: https://zap.redblox.dev/usage/generated-api.html

Registers a listener for a ManyAsync/ManySync event using the On function. The On function returns a Disconnect function that removes the listener; this example disconnects after 10 seconds.

```lua
local Disconnect = Zap.MyEvent.On(function(Options)
    -- Do something with the data
end)

task.delay(10, Disconnect)
```

--------------------------------

### Unit Enum Definition and Generated Luau Type

Source: https://zap.redblox.dev/config/types.html

Defines a unit enum named RoundStatus with values Starting, Playing, and Intermission. The generated Luau type is a union of string literals.

```zap
type RoundStatus = enum { Starting, Playing, Intermission }
```

```lua
type RoundStatus = "Starting" | "Playing" | "Intermission"
```

--------------------------------

### Set default server_output and client_output paths

Source: https://zap.redblox.dev/config/options.html

Default output paths for server and client code. When not using the CLI, these options can be ignored.

```lua
opt server_output = "./network/server.lua"
opt client_output = "path/to/client/output.lua"
```

```lua
opt server_output = "./network/client.luau"
opt client_output = "src/client/zap.luau"
```

--------------------------------

### Define a basic function with `funct`

Source: https://zap.redblox.dev/config/functions.html

Defines a function named `Test` with `call: Async`, named arguments `Foo` and `Bar`, and a return enum. The `call` field determines how the server listens; `args` and `rets` define the data sent and returned.

```zap
funct Test = {
call: Async,
args: (Foo: u8, Bar: string.utf8),
rets: enum { Success, Fail }
}
```

--------------------------------

### Enable include_profile_labels option

Source: https://zap.redblox.dev/config/options.html

Enables include_profile_labels, which adds microprofiler labels to the generated file to diagnose performance issues.

```text
opt include_profile_labels = true
```

--------------------------------

### Use generated Zap API: FireAll and On

Source: https://zap.redblox.dev/intro/getting-started.html

Server and client usage of generated Zap API. Server fires the event with FireAll; client subscribes with On and prints arguments.

```luau
local Zap = require(path.to.server.output)
Zap.MyEvent.FireAll(123, "hello world")
```

```luau
local Zap = require(path.to.client.output)
Zap.MyEvent.On(function(Foo, Bar)
print(Foo, Bar)
end)
```

--------------------------------

### Optional Instance type

Source: https://zap.redblox.dev/config/types.html

Defines a Character type as an optional Instance.Player. Appending ? after the whole type makes it optional.

```zap
type Character = Instance.Player?
```

--------------------------------

### Server Event FireAll

Source: https://zap.redblox.dev/usage/generated-api.html

Fires an event to all players from the server.

```APIDOC
## [Server Event] FireAll

### Description
Fires an event to all players from the server. More efficient than firing individually. Can be disabled with `disable_fire_all` option.

### Method
FireAll

### Parameters
- **data** (varies) - Required - The event's data fields, in order.

### Example
```lua
Zap.MyEvent.FireAll({
    foo = "baz",
    bar = 1,
})
```
```

--------------------------------

### Call a server function (GetScore.Call)

Source: https://zap.redblox.dev/usage/generated-api.html

Invokes the server function from the client using Call. Passes the function arguments directly and prints the returned score.

```lua
local score = Zap.GetScore.Call("round_ipsum-lorem", "LowScore")
print(score)
```

--------------------------------

### Server Event FireList

Source: https://zap.redblox.dev/usage/generated-api.html

Fires an event to a list of players from the server.

```APIDOC
## [Server Event] FireList

### Description
Fires an event to a list of players from the server. More efficient than firing individually.

### Method
FireList

### Parameters
- **players** (table) - Required - A list of players to receive the event.
- **data** (varies) - Required - The event's data fields, in order.

### Example
```lua
Zap.MyEvent.FireList({ Player1, Player2 }, {
    foo = "baz",
    bar = 1,
})
```
```

--------------------------------

### FireList to a list of players (MyEvent.FireList)

Source: https://zap.redblox.dev/usage/generated-api.html

Fires the event to a list of players using FireList. The first argument is a list of Player objects, followed by the event's data.

```lua
Zap.MyEvent.FireList({ Player1, Player2 }, {
    foo = "baz",
    bar = 1,
})
```

--------------------------------

### Define functions with unnamed parameters

Source: https://zap.redblox.dev/config/functions.html

Shows two functions with unnamed parameters. `OneUnnamedParameter` uses a single unnamed `u8` argument; `TwoUnnamedParameters` uses a tuple of two unnamed types. Parameter names and parentheses are optional for backwards compatibility.

```zap
funct OneUnnamedParameter = {
call: Async,
args: u8,
rets: enum { Success, Fail }
}
```

```zap
funct TwoUnnamedParameters = {
call: Async,
args: (u8, string.utf8),
rets: enum { Success, Fail }
}
```

--------------------------------

### Define events with unnamed data parameters

Source: https://zap.redblox.dev/config/events.html

Shows two event definitions: OneUnnamedParameter with a single unnamed boolean parameter, and TwoUnnamedParameters with two unnamed parameters (boolean and u32). Demonstrates that parentheses and parameter names are optional.

```zap
event OneUnnamedParameter = {
from: Server,
type: Reliable,
call: ManyAsync,
data: boolean
}
```

```zap
event TwoUnnamedParameters = {
from: Server,
type: Reliable,
call: ManyAsync,
data: (boolean, u32)
}
```

--------------------------------

### Deserialise compressed data with zap_deserialiser

Source: https://zap.redblox.dev/usage/tooling.html

Shows how to require the generated deserialiser and connect it to both reliable and unreliable remote events. The deserialiser takes the remote instance and all arguments sent through it, returning decompressed data. Note that running side effects on deserialised data is not intended behavior.

```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local zap_deserialiser = require(path.to.deserialiser)
local reliable = ReplicatedStorage:WaitForChild("ZAP_RELIABLE")
local unreliable = ReplicatedStorage:WaitForChild("ZAP_UNRELIABLE")
reliable.OnClientEvent:Connect(function(...)
local data = zap_deserialiser(reliable, ...)
print(data)
end)
unreliable.OnClientEvent:Connect(function(...)
local data = zap_deserialiser(unreliable, ...)
print(data)
end)
```

--------------------------------

### Define a basic event with four fields

Source: https://zap.redblox.dev/config/events.html

Shows the syntax for defining an event named MyEvent with fields from, type, call, and data. The data field uses named parameters with types boolean, u32, and string.utf8.

```zap
event MyEvent = {
from: Server,
type: Reliable,
call: ManyAsync,
data: (Foo: boolean, Bar: u32, Baz: string.utf8)
}
```

--------------------------------

### zap path/to/config.zap: generate code from config

Source: https://zap.redblox.dev/intro/getting-started.html

Generate Luau files from a Zap configuration file using the CLI. The command outputs server and client files at the paths specified in the config.

```bash
zap path/to/config.zap
```

--------------------------------

### Fire server event to one player (MyEvent.Fire)

Source: https://zap.redblox.dev/usage/generated-api.html

Fires the event to a single player from the server using the Fire function. Requires a Player object and the event's data as a table.

```lua
Zap.MyEvent.Fire(Player, {
    foo = "baz",
    bar = 1,
})
```

--------------------------------

### Configure types_output for Luau types

Source: https://zap.redblox.dev/config/options.html

Specify where Luau types are output. Relative to the configuration file and should point to a Lua(u) file.

```lua
opt types_output = "network/types.luau"
```

--------------------------------

### Fire client event (AnotherEvent.Fire)

Source: https://zap.redblox.dev/usage/generated-api.html

Fires the client event from the client using the Fire function. Data is passed as arguments in the order defined by the event's data tuple.

```lua
Zap.AnotherEvent.Fire(true, 32)
```

--------------------------------

### SetCallback for a server function (GetScore.SetCallback)

Source: https://zap.redblox.dev/usage/generated-api.html

Sets the server callback for a function using SetCallback. The callback must match the function's signature and return the configured type (here, a u16).

```lua
local function handleRequest(Player: Player, roundId: string, category: "HighScore" | "LowScore" | "AverageScore"): number
    -- Do something with the data.
    return 0 -- We must return a u16 according to our Zap config.
end

Zap.GetScore.SetCallback(handleRequest)
```

--------------------------------

### Client Event Fire

Source: https://zap.redblox.dev/usage/generated-api.html

Fires an event from the client to the server.

```APIDOC
## [Client Event] Fire

### Description
Fires an event from the client to the server. Takes the event's data as arguments.

### Method
Fire

### Parameters
- **data** (varies) - Required - The event's data fields, in order.

### Example
```lua
Zap.AnotherEvent.Fire(true, 32)
```
```

--------------------------------

### Server Event Fire

Source: https://zap.redblox.dev/usage/generated-api.html

Fires an event to a specific player from the server.

```APIDOC
## [Server Event] Fire

### Description
Fires an event to a specific player from the server.

### Method
Fire

### Parameters
- **player** (Player) - Required - The player to receive the event.
- **data** (varies) - Required - The event's data fields, in order.

### Example
```lua
Zap.MyEvent.Fire(Player, {
    foo = "baz",
    bar = 1,
})
```
```

--------------------------------

### Struct Definition for Shop Item

Source: https://zap.redblox.dev/config/types.html

Defines a struct named Item with fields name (string) and price (u16).

```zap
type Item = struct {
name: string,
price: u16,
}
```

--------------------------------

### FireSet to a set of players (MyEvent.FireSet)

Source: https://zap.redblox.dev/usage/generated-api.html

Fires the event to a set of players using FireSet. A set is a table where keys are of a certain datatype and values are always true.

```lua
Zap.MyEvent.FireSet({
    [Player1] = true,
    [Player2] = true,
}, {
    foo = "baz",
    bar = 1,
})
```

--------------------------------

### Enable manual_event_loop option

Source: https://zap.redblox.dev/config/options.html

Enables the manual_event_loop option, which requires the SendEvents function to be called manually each frame.

```text
opt manual_event_loop = true
```

--------------------------------

### FireAll to all players (MyEvent.FireAll)

Source: https://zap.redblox.dev/usage/generated-api.html

Fires the event to all players using FireAll. Can be disabled with the disable_fire_all option; attempting to call when disabled produces an error.

```lua
Zap.MyEvent.FireAll({
    foo = "baz",
    bar = 1,
})
```

--------------------------------

### Client Function Call

Source: https://zap.redblox.dev/usage/generated-api.html

Invokes a server function from the client.

```APIDOC
## [Client Function] Call

### Description
Invokes a server function from the client. Takes the function's arguments and returns the result.

### Method
Call

### Parameters
- **args** (varies) - Required - The function's arguments, in order.

### Returns
- **result** (varies) - The return value of the server function.

### Example
```lua
local score = Zap.GetScore.Call("round_ipsum-lorem", "LowScore")
print(score)
```
```

--------------------------------

### Server Event FireSet

Source: https://zap.redblox.dev/usage/generated-api.html

Fires an event to a set of players from the server.

```APIDOC
## [Server Event] FireSet

### Description
Fires an event to a set of players from the server. More efficient than firing individually.

### Method
FireSet

### Parameters
- **players** (table) - Required - A set of players (keys) with `true` values.
- **data** (varies) - Required - The event's data fields, in order.

### Example
```lua
Zap.MyEvent.FireSet({
    [Player1] = true,
    [Player2] = true,
}, {
    foo = "baz",
    bar = 1,
})
```
```

--------------------------------

### FireExcept to all but one player (MyEvent.FireExcept)

Source: https://zap.redblox.dev/usage/generated-api.html

Fires the event to all players except the specified player using FireExcept. Takes a Player and the event's data.

```lua
Zap.MyEvent.FireExcept(Player, {
    foo = "baz",
    bar = 1,
})
```

--------------------------------

### SetCallback for SingleAsync events (AnotherEvent)

Source: https://zap.redblox.dev/usage/generated-api.html

Assigns a single listener to a SingleAsync/SingleSync event using SetCallback. Only server listeners receive the Player argument. Cannot be used on Many-style events.

```lua
Zap.AnotherEvent.SetCallback(function(Player, Foo, Bar)
    -- Do something with the player and data
end)
```

--------------------------------

### Server Event FireExcept

Source: https://zap.redblox.dev/usage/generated-api.html

Fires an event to all players except the specified player from the server.

```APIDOC
## [Server Event] FireExcept

### Description
Fires an event to all players except the specified player from the server.

### Method
FireExcept

### Parameters
- **player** (Player) - Required - The player to exclude.
- **data** (varies) - Required - The event's data fields, in order.

### Example
```lua
Zap.MyEvent.FireExcept(Player, {
    foo = "baz",
    bar = 1,
})
```
```

--------------------------------

### Manual event loop: throttle Zap.SendEvents() to 60 Hz

Source: https://zap.redblox.dev/config/options.html

Use this to manually send reliable events at a timed rate when manual_event_loop is enabled. The code fires Zap.SendEvents() only when at least 1/60 of a second has elapsed, limiting the send rate to 60 Hz to avoid the Roblox issue of high network response times and server crashes.

```lua
local Timer = 0

RunService.Heartbeat:Connect(function(DeltaTime)
	Timer += DeltaTime

	-- Only send events 60 times per second
	if Timer >= 1 / 60 then
		Timer = 0
		Zap.SendEvents()
	end
end)
```

--------------------------------

### zap_deserialiser

Source: https://zap.redblox.dev/usage/tooling.html

Describes the generated deserialiser function that can be used to read compressed data from Zap remotes.

```APIDOC
## [FUNCTION] zap_deserialiser

### Description
Deserialises compressed data sent through a remote event into a readable format for plugins and scripts. This function is generated by Zap and should be required from the output file.

### Parameters
- **remote** (RemoteEvent | UnreliableRemoteEvent) - Required - The remote instance itself.
- **...** (any) - Required - ALL arguments sent through the remote.

### Returns
Returns an array of objects with the following structure:
- **Name** (string) - The name of the event.
- **Arguments** (array of any) - The arguments sent through the remote.

If the `tooling_show_internal_data` argument is `true`, the first element of the array is an object with:
- **EventId** (number) - The event ID.
- **CallId** (number, optional) - The call ID.

### Example
```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local zap_deserialiser = require(path.to.deserialiser)
local reliable = ReplicatedStorage:WaitForChild("ZAP_RELIABLE")
local unreliable = ReplicatedStorage:WaitForChild("ZAP_UNRELIABLE")

reliable.OnClientEvent:Connect(function(...)
    local data = zap_deserialiser(reliable, ...)
    print(data)
end)

unreliable.OnClientEvent:Connect(function(...)
    local data = zap_deserialiser(unreliable, ...)
    print(data)
end)
```
```

--------------------------------

### Define a function with multiple return values

Source: https://zap.redblox.dev/config/functions.html

Defines a function `MultipleRets` that returns multiple values by wrapping them in parentheses. `rets` cannot be named, unlike `args`.

```zap
funct MultipleRets = {
call: Async,
args: boolean,
rets: (enum { Success, Fail }, string.utf8)
}
```

--------------------------------

### Set typescript_max_tuple_length option

Source: https://zap.redblox.dev/config/options.html

Sets typescript_max_tuple_length to 5, so tuples longer than 5 generate an array instead.

```text
opt typescript_max_tuple_length = 5
```

--------------------------------

### Event On

Source: https://zap.redblox.dev/usage/generated-api.html

Assigns a listener to an event with ManyAsync or ManySync call type. Returns a disconnect function.

```APIDOC
## [Event] On

### Description
Assigns a listener to an event with `ManyAsync` or `ManySync` call type. Multiple listeners can be assigned. Returns a disconnect function.

### Method
On

### Parameters
- **callback** (function) - Required - The function to be called when the event is fired. On the server, the first argument is the Player.

### Returns
- **Disconnect** (function) - A function that removes the listener when called.

### Example
```lua
local Disconnect = Zap.MyEvent.On(function(Options)
    -- Do something with the data
end)

task.delay(10, Disconnect)
```
```

--------------------------------

### Server Function SetCallback

Source: https://zap.redblox.dev/usage/generated-api.html

Sets the callback that handles client invocations for a function.

```APIDOC
## [Server Function] SetCallback

### Description
Sets the callback that handles client invocations for a function. The callback must return the type defined in the Zap config.

### Method
SetCallback

### Parameters
- **callback** (function) - Required - The function that handles the request. Receives the Player and the function's arguments. Must return the configured return type.

### Example
```lua
local function handleRequest(Player: Player, roundId: string, category: "HighScore" | "LowScore" | "AverageScore"): number
    -- Do something with the data.
    return 0 -- We must return a u16 according to our Zap config.
end

Zap.GetScore.SetCallback(handleRequest)
```
```

--------------------------------

### Vector type with u8 and f32 components

Source: https://zap.redblox.dev/config/types.html

Defines a Size type as a vector with u8 and f32 components. The Z component is optional and defaults to 0 if omitted.

```zap
type Size = vector(u8, f32)
```

--------------------------------

### Event SetCallback

Source: https://zap.redblox.dev/usage/generated-api.html

Assigns a single callback to an event with SingleAsync or SingleSync call type.

```APIDOC
## [Event] SetCallback

### Description
Assigns a single callback to an event with `SingleAsync` or `SingleSync` call type. Only one listener can be assigned.

### Method
SetCallback

### Parameters
- **callback** (function) - Required - The function to be called when the event is fired. On the server, the first argument is the Player.

### Example
```lua
Zap.AnotherEvent.SetCallback(function(Player, Foo, Bar)
    -- Do something with the player and data
end)
```
```

--------------------------------

### Set remote_scope to customize generated remote names

Source: https://zap.redblox.dev/config/options.html

Change the name of generated remotes. Default ZAP produces ZAP_RELIABLE and ZAP_UNRELIABLE. Custom names append _RELIABLE and _UNRELIABLE.

```lua
opt remote_scope = "ZAP"
```

```lua
opt remote_scope = "PACKAGE_NAME"
```

--------------------------------

### Set default call field (ManySync or Polling)

Source: https://zap.redblox.dev/config/options.html

Set the default call field for events to ManySync or Polling. Requires an explicit call field on every event if not set.

```lua
opt call_default = "ManySync"
```

```lua
opt call_default = "Polling"
```

--------------------------------

### InternalData type definition (Lua and TypeScript)

Source: https://zap.redblox.dev/usage/tooling.html

Defines the type of the first argument when the tooling_show_internal_data argument is true. The type respects your casing option. The next argument in the array is the data deserialised from the event itself, if it exists.

```lua
type InternalData = {
EventId: number,
CallId: number?
}
```

```typescript
interface InternalData {
EventId: number,
CallId?: number
}
```

--------------------------------

### Vector type with three f32 components

Source: https://zap.redblox.dev/config/types.html

Defines a Position type as a vector with three f32 components. This is a valid Zap vector type.

```zap
type Position = vector(f32, f32, f32)
```

--------------------------------

### Vector type with omitted components

Source: https://zap.redblox.dev/config/types.html

Defines a Position type as a vector with all components omitted, which emits vector(f32, f32, f32).

```zap
type Position = vector
```

--------------------------------

### DecompressedData type definition (Lua and TypeScript)

Source: https://zap.redblox.dev/usage/tooling.html

Defines the return type of the deserialiser function. The array contains objects with a Name string and an Arguments array. The Lua and TypeScript versions are equivalent.

```lua
type DecompressedData = { {
Name: string,
Arguments: { any },
} }
```

```typescript
type DecompressedData = {
Name: string,
Arguments: unknown[],
}[]
```

--------------------------------

### Set typescript_enum option to ConstEnum

Source: https://zap.redblox.dev/config/options.html

Sets typescript_enum to ConstEnum, which changes the TypeScript type generation to use const enum.

```text
opt typescript_enum = "ConstEnum"
```

--------------------------------

### Generated TypeScript for StringConstEnum

Source: https://zap.redblox.dev/config/options.html

This is the TypeScript type generated when typescript_enum is "StringConstEnum". It uses const enum with string values to avoid changing the Luau output to accept numbers.

```typescript
const enum RoundStatus {
	Starting = "Starting",
	Playing = "Playing",
	Intermission = "Intermission"
}
```

--------------------------------

### Tagged Enum Definition and Generated Luau Type

Source: https://zap.redblox.dev/config/types.html

Defines a tagged enum named Tagged with variants Number, String, and Boolean, each carrying a Value field. The generated Luau type is a union of object types with a tag field 'type'.

```zap
type Tagged = enum "Type" {
Number {
Value: f64,
},
String {
Value: string,
},
Boolean {
Value: boolean,
},
}
```

```lua
type t = { type: "number", value: number }
	| { type: "string", value: string }
	| { type: "boolean", value: boolean }
```

--------------------------------

### Generated TypeScript for StringLiteral

Source: https://zap.redblox.dev/config/options.html

This is the TypeScript type generated when typescript_enum is "StringLiteral", the default. The enum becomes a union of string literals.

```typescript
type RoundStatus = "Starting" | "Playing" | "Intermission"
```

--------------------------------

### Generated TypeScript for ConstEnum

Source: https://zap.redblox.dev/config/options.html

This is the TypeScript type generated when typescript_enum is "ConstEnum". Because const enum emits numbers by default, this changes the Luau output to accept numbers instead of strings for an enum.

```typescript
const enum RoundStatus {
	Starting,
	Playing,
	Intermission
}
```
Tokens:
Raw