Warp/docs/api/1.1/client.md

# Client <Badge type="tip" text="1.1" />

For Client-sided operations.

## Getting the Client Object

```lua
local Client = Warp.Client()
```

## `.awaitReady` <Badge type="warning" text="yield" />

Yields the current thread until the client has successfully initialized and synchronized with the server's replication data (identifier). Its optionally, but highly recommended to call this before firing or connecting to any events to ensure the network is fully ready.

::: code-group
```luau [Variable]
() -> ()
```

```luau [Example]
local Client = Warp.Client()

-- wait for the client to be fully initialized
Client.awaitReady()

print("Client is now ready to send and receive events! :D")
```
:::

## `.Connect`

Connect to an event to receive incoming data from the server.

::: code-group
```luau [Variable]
(
	remoteName: string,
	fn: (...any) -> ...any
) -> Connection
```

```luau [Example]
local connection = Client.Connect("ServerNotify", function(message, sender)
	print(`Server message from {sender}: {message}`)
end)
print(connection.Connected)
```
:::

## `.Once`

Similar to `:Connect` but automatically disconnects after the first firing.

::: code-group
```luau [Variable]
(
	remoteName: string,
	fn: (...any) -> ...any
) -> Connection
```

```luau [Example]
Client.Once("WelcomeMessage", function(welcomeText)
	print(`Welcome: {welcomeText}`)
end)
```
:::

## `.Wait` <Badge type="warning" text="yield" />

Wait for an event to be triggered.

::: code-group
```luau [Variable]
(
	remoteName: string
) -> (number, ...any)
```

```luau [Example]
local elapsed, message = Client.Wait("ServerMessage")
print(`Received message after {elapsed} seconds: {message}`)
```
:::

## `.Disconnect`

Disconnect the event connection.

::: code-group
```luau [Variable]
()
```

```luau [Example]
local connection = Client.Connect("ServerNotify", function(message, sender)
	print(`Server message from {sender}: {message}`)
	-- Disconnect the connection
	connection:Disconnect()
end)
print(Connection.Connected)
```
:::

## `.DisconnectAll`

Disconnect all connections for a specific event.

::: code-group
```luau [Variable]
(
	remoteName: string
)
```

```luau [Example]
Client.DisconnectAll("ServerNotify")
```
:::

## `.Destroy`

Disconnect all connections and remove the event.

::: code-group
```luau [Variable]
(
	remoteName: string
)
```

```luau [Example]
Client.Destroy("ServerNotify")
```
:::

## `.Fire`

Fire an event to the server.

::: code-group
```luau [Variable]
(
	remoteName: string,
	reliable: boolean,
	...: any
)
```

```luau [Example]
-- (TCP) Reliable event (guaranteed delivery)
Client.Fire("PlayerAction", true, "jump", playerPosition)

-- (UDP) Unreliable event (faster but not guaranteed)
Client.Fire("PositionUpdate", false, currentPosition)
```
:::

## `.Invoke` <Badge type="warning" text="yield" />

Invoke the server with timeout support.

::: code-group
```luau [Variable]
(
	remoteName: string,
	timeout: number?,
	...: any
) -> ...any
```

```luau [Example]
local Client = Warp.Client()
local response = Client.Invoke("RequestData", 3, "playerStats")
if response then
	print("Server responded:", response)
else
	print("Request timed out")
end
```
:::

::: warning
This function is yielded. Returns `nil` if timeout occurs.
:::

## `.useSchema`

Define a schema for strict data packing on a specific event.

::: code-group
```luau [Variable]
(
	remoteName: string,
	schema: Buffer.SchemaType
)
```

```luau [Example]
local Client = Warp.Client()

-- Define a schema for position updates
local positionSchema = Client.Schema.struct({
	x = Client.Schema.f32,
	y = Client.Schema.f32,
	z = Client.Schema.f32,
	timestamp = Client.Schema.u32
})
-- Define a schema for data updates
local dataSchema = Client.Schema.struct({
	Coins = Client.Schema.u32,
	Level = Client.Schema.u8,
	Inventory = Client.Schema.array(Client.Schema.u32),
	Settings = Client.Schema.struct({
		VFX = Client.Schema.boolean,
		Volume = Client.Schema.f32,
		Language = Client.Schema.string,
	})
})

-- Now this event will use the schema
Client.useSchema("DataReplication", dataSchema)
Client.useSchema("PositionUpdate", positionSchema)
Client.Connect("PositionUpdate", function(x, y, z, timestamp)
	-- Data is automatically deserialized according to schema
	updatePlayerPosition(x, y, z)
end)
```
:::

## `.Schema`

Access to Buffer.Schema for creating data schemas.