@my-swu/simulator-client

---

@my-swu/simulator-client / SchemaTypeMap

Interface: SchemaTypeMap

Defined in: packages/ts-sdk/src/validators.ts:153

Exact schema-to-type map generated from Rust public wire contracts.

Keys match generated schema names. Values are the TypeScript types returned after runtime validation succeeds.

Example:

import { parseSchema } from '@my-swu/simulator-client'

// Runtime validation narrows payloads to generated TypeScript types.
const health = parseSchema('health-response', { buildSha: 'development', status: 'ok' })

console.log(health.status)

See

https://simulator-sdk.my-swu.com/guide/versioning

Properties

abandon-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const abandonMatchRequestPayload = {}

const parsedPayload = parseSchema('abandon-match-request', abandonMatchRequestPayload)

console.log(parsedPayload)

abandon-match-request: AbandonMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:160

---

abandon-match-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const abandonMatchResponsePayload = {}

const parsedPayload = parseSchema('abandon-match-response', abandonMatchResponsePayload)

console.log(parsedPayload)

abandon-match-response: AbandonMatchResponse

Defined in: packages/ts-sdk/src/validators.ts:161

---

add-lobby-ai-player-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const addLobbyAiPlayerRequestPayload = {}

const parsedPayload = parseSchema('add-lobby-ai-player-request', addLobbyAiPlayerRequestPayload)

console.log(parsedPayload)

add-lobby-ai-player-request: AddLobbyAiPlayerRequest

Defined in: packages/ts-sdk/src/validators.ts:200

---

admin-match-debug-bundle

Example:

import { parseSchema } from '@my-swu/simulator-client'

const adminMatchDebugBundlePayload = {}

const parsedPayload = parseSchema('admin-match-debug-bundle', adminMatchDebugBundlePayload)

console.log(parsedPayload)

admin-match-debug-bundle: AdminMatchDebugBundle

Defined in: packages/ts-sdk/src/validators.ts:155

---

admin-match-list-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const adminMatchListResponsePayload = {}

const parsedPayload = parseSchema('admin-match-list-response', adminMatchListResponsePayload)

console.log(parsedPayload)

admin-match-list-response: AdminMatchListResponse

Defined in: packages/ts-sdk/src/validators.ts:154

---

admin-match-replay-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const adminMatchReplayResponsePayload = {}

const parsedPayload = parseSchema('admin-match-replay-response', adminMatchReplayResponsePayload)

console.log(parsedPayload)

admin-match-replay-response: AdminMatchReplayResponse

Defined in: packages/ts-sdk/src/validators.ts:156

---

api-error-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const apiErrorResponsePayload = { error: { code: 'match_not_found', message: 'Match not found' } }

const parsedPayload = parseSchema('api-error-response', apiErrorResponsePayload)

console.log(parsedPayload)

api-error-response: ApiErrorResponse

Defined in: packages/ts-sdk/src/validators.ts:167

---

become-lobby-spectator-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const becomeLobbySpectatorRequestPayload = {}

const parsedPayload = parseSchema('become-lobby-spectator-request', becomeLobbySpectatorRequestPayload)

console.log(parsedPayload)

become-lobby-spectator-request: BecomeLobbySpectatorRequest

Defined in: packages/ts-sdk/src/validators.ts:194

---

card-catalog-refresh-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const cardCatalogRefreshResponsePayload = {}

const parsedPayload = parseSchema('card-catalog-refresh-response', cardCatalogRefreshResponsePayload)

console.log(parsedPayload)

card-catalog-refresh-response: CardCatalogRefreshResponse

Defined in: packages/ts-sdk/src/validators.ts:169

---

cards-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const cardsResponsePayload = { cards: [] }

const parsedPayload = parseSchema('cards-response', cardsResponsePayload)

console.log(parsedPayload)

cards-response: CardsResponse

Defined in: packages/ts-sdk/src/validators.ts:168

---

client-message

Example:

import { parseSchema } from '@my-swu/simulator-client'

const clientMessagePayload = { type: 'ready' }

const parsedPayload = parseSchema('client-message', clientMessagePayload)

console.log(parsedPayload)

client-message: ClientMessage

Defined in: packages/ts-sdk/src/validators.ts:170

---

close-tournament-room-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const closeTournamentRoomRequestPayload = {}

const parsedPayload = parseSchema('close-tournament-room-request', closeTournamentRoomRequestPayload)

console.log(parsedPayload)

close-tournament-room-request: CloseTournamentRoomRequest

Defined in: packages/ts-sdk/src/validators.ts:159

---

create-limited-event-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createLimitedEventRequestPayload = {
  kind: 'draft',
  draftRounds: [], // Chaos draft only; a plain draft repeats `setCode`.
  pickTimerEnabled: false,
  setCode: 'SOR',
  playerCount: 4,
}

const parsedPayload = parseSchema('create-limited-event-request', createLimitedEventRequestPayload)

console.log(parsedPayload)

create-limited-event-request: CreateLimitedEventRequest

Defined in: packages/ts-sdk/src/validators.ts:171

---

create-lobby-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createLobbyRequestPayload = {}

const parsedPayload = parseSchema('create-lobby-request', createLobbyRequestPayload)

console.log(parsedPayload)

create-lobby-request: CreateLobbyRequest

Defined in: packages/ts-sdk/src/validators.ts:172

---

create-match-history-replay-share-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createMatchHistoryReplayShareRequestPayload = {}

const parsedPayload = parseSchema(
  'create-match-history-replay-share-request',
  createMatchHistoryReplayShareRequestPayload,
)

console.log(parsedPayload)

create-match-history-replay-share-request: CreateMatchHistoryReplayShareRequest

Defined in: packages/ts-sdk/src/validators.ts:220

---

create-match-history-replay-share-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createMatchHistoryReplayShareResponsePayload = {}

const parsedPayload = parseSchema(
  'create-match-history-replay-share-response',
  createMatchHistoryReplayShareResponsePayload,
)

console.log(parsedPayload)

create-match-history-replay-share-response: CreateMatchHistoryReplayShareResponse

Defined in: packages/ts-sdk/src/validators.ts:221

---

create-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

// Use card ids; the server validates deck legality.
const premierHostDeck = {
  leader: 46102, // Leia Organa - Someone Who Loves You
  leaders: [], // Twin Suns only; Premier uses the single `leader` above.
  base: 308, // Echo Base
  cards: Array.from({ length: 50 }, () => 45), // Alliance X-Wing
  sideboard: [],
}

const createMatchRequest = {
  format: 'premier',
  // Twin Suns supports 2-4 players; every other format is exactly 2.
  playerCount: 2,
  hostName: 'Host',
  hostAuthenticated: false,
  historyIdentities: [],
  // One entry per AI-controlled seat; empty means a human opponent joins.
  aiOpponents: [],
  hostDeck: premierHostDeck,
}

const parsedPayload = parseSchema('create-match-request', createMatchRequest)

console.log(parsedPayload)

create-match-request: CreateMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:174

---

create-meta-window-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createMetaWindowRequestPayload = {}

const parsedPayload = parseSchema('create-meta-window-request', createMetaWindowRequestPayload)

console.log(parsedPayload)

create-meta-window-request: CreateMetaWindowRequest

Defined in: packages/ts-sdk/src/validators.ts:173

---

create-playground-share-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createPlaygroundShareResponsePayload = {}

const parsedPayload = parseSchema('create-playground-share-response', createPlaygroundShareResponsePayload)

console.log(parsedPayload)

create-playground-share-response: CreatePlaygroundShareResponse

Defined in: packages/ts-sdk/src/validators.ts:258

---

create-tournament-room-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createTournamentRoomRequestPayload = {}

const parsedPayload = parseSchema('create-tournament-room-request', createTournamentRoomRequestPayload)

console.log(parsedPayload)

create-tournament-room-request: CreateTournamentRoomRequest

Defined in: packages/ts-sdk/src/validators.ts:175

---

create-tournament-table-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const createTournamentTableRequestPayload = {}

const parsedPayload = parseSchema('create-tournament-table-request', createTournamentTableRequestPayload)

console.log(parsedPayload)

create-tournament-table-request: CreateTournamentTableRequest

Defined in: packages/ts-sdk/src/validators.ts:176

---

error-payload

Example:

import { parseSchema } from '@my-swu/simulator-client'

const errorPayloadPayload = { code: 'invalid_selection', message: 'Deck must include a leader' }

const parsedPayload = parseSchema('error-payload', errorPayloadPayload)

console.log(parsedPayload)

error-payload: ErrorPayload

Defined in: packages/ts-sdk/src/validators.ts:177

---

format-event-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const formatEventRequestPayload = { seatToken: 'seat_token_123', command: { type: 'readyNextGame' } }

const parsedPayload = parseSchema('format-event-request', formatEventRequestPayload)

console.log(parsedPayload)

format-event-request: FormatEventRequest

Defined in: packages/ts-sdk/src/validators.ts:178

---

format-event-response

Example:

import { createSimulatorClient, parseSchema } from '@my-swu/simulator-client'

const simulatorClient = createSimulatorClient({
  baseUrl: 'http://127.0.0.1:4000',
})

const matchSnapshot = await simulatorClient.matches.get('match_123')
const formatEventResponse = { snapshot: matchSnapshot }

const parsedPayload = parseSchema('format-event-response', formatEventResponse)

console.log(parsedPayload)

format-event-response: FormatEventResponse

Defined in: packages/ts-sdk/src/validators.ts:179

---

game-command

Example:

import { parseSchema } from '@my-swu/simulator-client'

const gameCommandPayload = 'pass'

const parsedPayload = parseSchema('game-command', gameCommandPayload)

console.log(parsedPayload)

game-command: GameCommand

Defined in: packages/ts-sdk/src/validators.ts:180

---

game-event

Example:

import { parseSchema } from '@my-swu/simulator-client'

const gameEventPayload = { playerReady: { seat: 'one' } }

const parsedPayload = parseSchema('game-event', gameEventPayload)

console.log(parsedPayload)

game-event: GameEvent

Defined in: packages/ts-sdk/src/validators.ts:181

---

game-state

Example:

import { createSimulatorClient, parseSchema } from '@my-swu/simulator-client'

const simulatorClient = createSimulatorClient({
  baseUrl: 'http://127.0.0.1:4000',
})

const matchSnapshot = await simulatorClient.matches.get('match_123')

const parsedPayload = parseSchema('game-state', matchSnapshot)

console.log(parsedPayload)

game-state: GameState

Defined in: packages/ts-sdk/src/validators.ts:182

---

get-match-response

Example:

import { createSimulatorClient, parseSchema } from '@my-swu/simulator-client'

const simulatorClient = createSimulatorClient({
  baseUrl: 'http://127.0.0.1:4000',
})

const matchSnapshot = await simulatorClient.matches.get('match_123')
const getMatchResponse = { snapshot: matchSnapshot }

const parsedPayload = parseSchema('get-match-response', getMatchResponse)

console.log(parsedPayload)

get-match-response: GetMatchResponse

Defined in: packages/ts-sdk/src/validators.ts:183

---

health-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const healthResponsePayload = { buildSha: 'development', status: 'ok' }

const parsedPayload = parseSchema('health-response', healthResponsePayload)

console.log(parsedPayload)

health-response: HealthResponse

Defined in: packages/ts-sdk/src/validators.ts:184

---

join-limited-event-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const joinLimitedEventRequest = {}

const parsedPayload = parseSchema('join-limited-event-request', joinLimitedEventRequest)

console.log(parsedPayload)

join-limited-event-request: JoinLimitedEventRequest

Defined in: packages/ts-sdk/src/validators.ts:185

---

join-lobby-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const joinLobbyRequestPayload = {}

const parsedPayload = parseSchema('join-lobby-request', joinLobbyRequestPayload)

console.log(parsedPayload)

join-lobby-request: JoinLobbyRequest

Defined in: packages/ts-sdk/src/validators.ts:187

---

join-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

// Seat two submits a separate legal deck when joining the match.
const premierGuestDeck = {
  leader: 46107, // Darth Vader - Unstoppable
  leaders: [],
  base: 309, // Tarkintown
  cards: Array.from({ length: 50 }, () => 35), // TIE/ln Fighter
  sideboard: [],
}

const joinMatchRequest = {
  deck: premierGuestDeck,
  name: 'Guest',
  authenticated: false,
  historyIdentities: [],
}

const parsedPayload = parseSchema('join-match-request', joinMatchRequest)

console.log(parsedPayload)

join-match-request: JoinMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:188

---

join-tournament-room-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const joinTournamentRoomRequestPayload = {}

const parsedPayload = parseSchema('join-tournament-room-request', joinTournamentRoomRequestPayload)

console.log(parsedPayload)

join-tournament-room-request: JoinTournamentRoomRequest

Defined in: packages/ts-sdk/src/validators.ts:189

---

join-tournament-table-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const joinTournamentTableRequestPayload = {}

const parsedPayload = parseSchema('join-tournament-table-request', joinTournamentTableRequestPayload)

console.log(parsedPayload)

join-tournament-table-request: JoinTournamentTableRequest

Defined in: packages/ts-sdk/src/validators.ts:190

---

kick-lobby-player-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const kickLobbyPlayerRequestPayload = {}

const parsedPayload = parseSchema('kick-lobby-player-request', kickLobbyPlayerRequestPayload)

console.log(parsedPayload)

kick-lobby-player-request: KickLobbyPlayerRequest

Defined in: packages/ts-sdk/src/validators.ts:191

---

kick-lobby-spectator-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const kickLobbySpectatorRequestPayload = {}

const parsedPayload = parseSchema('kick-lobby-spectator-request', kickLobbySpectatorRequestPayload)

console.log(parsedPayload)

kick-lobby-spectator-request: KickLobbySpectatorRequest

Defined in: packages/ts-sdk/src/validators.ts:192

---

leave-limited-event-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const leaveLimitedEventRequestPayload = {}

const parsedPayload = parseSchema('leave-limited-event-request', leaveLimitedEventRequestPayload)

console.log(parsedPayload)

leave-limited-event-request: LeaveLimitedEventRequest

Defined in: packages/ts-sdk/src/validators.ts:186

---

leave-lobby-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const leaveLobbyRequestPayload = {}

const parsedPayload = parseSchema('leave-lobby-request', leaveLobbyRequestPayload)

console.log(parsedPayload)

leave-lobby-request: LeaveLobbyRequest

Defined in: packages/ts-sdk/src/validators.ts:193

---

leave-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const leaveMatchRequestPayload = {}

const parsedPayload = parseSchema('leave-match-request', leaveMatchRequestPayload)

console.log(parsedPayload)

leave-match-request: LeaveMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:162

---

leave-match-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const leaveMatchResponsePayload = {}

const parsedPayload = parseSchema('leave-match-response', leaveMatchResponsePayload)

console.log(parsedPayload)

leave-match-response: LeaveMatchResponse

Defined in: packages/ts-sdk/src/validators.ts:163

---

leave-tournament-room-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const leaveTournamentRoomRequestPayload = {}

const parsedPayload = parseSchema('leave-tournament-room-request', leaveTournamentRoomRequestPayload)

console.log(parsedPayload)

leave-tournament-room-request: LeaveTournamentRoomRequest

Defined in: packages/ts-sdk/src/validators.ts:164

---

limited-event-access-response

Example:

import { createSimulatorClient, parseSchema } from '@my-swu/simulator-client'

const simulatorClient = createSimulatorClient({
  baseUrl: 'http://127.0.0.1:4000',
})

const draftEventAccess = await simulatorClient.limitedEvents.create({
  kind: 'draft',
  draftRounds: [], // Chaos draft only; a plain draft repeats `setCode`.
  pickTimerEnabled: false,
  setCode: 'SOR',
  playerCount: 4,
})

const parsedPayload = parseSchema('limited-event-access-response', draftEventAccess)

console.log(parsedPayload)

limited-event-access-response: LimitedEventAccessResponse

Defined in: packages/ts-sdk/src/validators.ts:195

---

limited-event-command-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const limitedEventCommandRequestPayload = { seatToken: 'limited_token_123', command: { type: 'readyForNextDraft' } }

const parsedPayload = parseSchema('limited-event-command-request', limitedEventCommandRequestPayload)

console.log(parsedPayload)

limited-event-command-request: LimitedEventCommandRequest

Defined in: packages/ts-sdk/src/validators.ts:196

---

limited-event-preflight-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const limitedEventPreflightResponsePayload = {}

const parsedPayload = parseSchema('limited-event-preflight-response', limitedEventPreflightResponsePayload)

console.log(parsedPayload)

limited-event-preflight-response: LimitedEventPreflightResponse

Defined in: packages/ts-sdk/src/validators.ts:197

---

limited-event-response

Example:

import { createSimulatorClient, parseSchema } from '@my-swu/simulator-client'

const simulatorClient = createSimulatorClient({
  baseUrl: 'http://127.0.0.1:4000',
})

const limitedEventSnapshot = await simulatorClient.limitedEvents.get({
  eventId: 'event_123',
  seatToken: 'limited_token_123',
})
const limitedEventResponse = { snapshot: limitedEventSnapshot }

const parsedPayload = parseSchema('limited-event-response', limitedEventResponse)

console.log(parsedPayload)

limited-event-response: LimitedEventResponse

Defined in: packages/ts-sdk/src/validators.ts:198

---

limited-event-server-message

Example:

import { parseSchema } from '@my-swu/simulator-client'

const limitedEventServerMessagePayload = {}

const parsedPayload = parseSchema('limited-event-server-message', limitedEventServerMessagePayload)

console.log(parsedPayload)

limited-event-server-message: LimitedEventServerMessage

Defined in: packages/ts-sdk/src/validators.ts:199

---

list-active-ai-matches-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const listActiveAiMatchesRequestPayload = {}

const parsedPayload = parseSchema('list-active-ai-matches-request', listActiveAiMatchesRequestPayload)

console.log(parsedPayload)

list-active-ai-matches-request: ListActiveAiMatchesRequest

Defined in: packages/ts-sdk/src/validators.ts:165

---

list-active-ai-matches-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const listActiveAiMatchesResponsePayload = {}

const parsedPayload = parseSchema('list-active-ai-matches-response', listActiveAiMatchesResponsePayload)

console.log(parsedPayload)

list-active-ai-matches-response: ListActiveAiMatchesResponse

Defined in: packages/ts-sdk/src/validators.ts:166

---

lobby-access-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyAccessResponsePayload = {}

const parsedPayload = parseSchema('lobby-access-response', lobbyAccessResponsePayload)

console.log(parsedPayload)

lobby-access-response: LobbyAccessResponse

Defined in: packages/ts-sdk/src/validators.ts:201

---

lobby-chat-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyChatRequestPayload = {}

const parsedPayload = parseSchema('lobby-chat-request', lobbyChatRequestPayload)

console.log(parsedPayload)

lobby-chat-request: LobbyChatRequest

Defined in: packages/ts-sdk/src/validators.ts:202

---

lobby-chat-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyChatResponsePayload = {}

const parsedPayload = parseSchema('lobby-chat-response', lobbyChatResponsePayload)

console.log(parsedPayload)

lobby-chat-response: LobbyChatResponse

Defined in: packages/ts-sdk/src/validators.ts:203

---

lobby-list-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyListResponsePayload = {}

const parsedPayload = parseSchema('lobby-list-response', lobbyListResponsePayload)

console.log(parsedPayload)

lobby-list-response: LobbyListResponse

Defined in: packages/ts-sdk/src/validators.ts:204

---

lobby-list-server-message

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyListServerMessagePayload = {}

const parsedPayload = parseSchema('lobby-list-server-message', lobbyListServerMessagePayload)

console.log(parsedPayload)

lobby-list-server-message: LobbyListServerMessage

Defined in: packages/ts-sdk/src/validators.ts:205

---

lobby-matchmaking-decision-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyMatchmakingDecisionRequestPayload = {}

const parsedPayload = parseSchema('lobby-matchmaking-decision-request', lobbyMatchmakingDecisionRequestPayload)

console.log(parsedPayload)

lobby-matchmaking-decision-request: LobbyMatchmakingDecisionRequest

Defined in: packages/ts-sdk/src/validators.ts:206

---

lobby-matchmaking-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyMatchmakingRequestPayload = {}

const parsedPayload = parseSchema('lobby-matchmaking-request', lobbyMatchmakingRequestPayload)

console.log(parsedPayload)

lobby-matchmaking-request: LobbyMatchmakingRequest

Defined in: packages/ts-sdk/src/validators.ts:236

---

lobby-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyResponsePayload = {}

const parsedPayload = parseSchema('lobby-response', lobbyResponsePayload)

console.log(parsedPayload)

lobby-response: LobbyResponse

Defined in: packages/ts-sdk/src/validators.ts:207

---

lobby-server-message

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbyServerMessagePayload = {}

const parsedPayload = parseSchema('lobby-server-message', lobbyServerMessagePayload)

console.log(parsedPayload)

lobby-server-message: LobbyServerMessage

Defined in: packages/ts-sdk/src/validators.ts:208

---

lobby-sync-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const lobbySyncRequestPayload = {}

const parsedPayload = parseSchema('lobby-sync-request', lobbySyncRequestPayload)

console.log(parsedPayload)

lobby-sync-request: LobbySyncRequest

Defined in: packages/ts-sdk/src/validators.ts:209

---

match-access-recovery-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchAccessRecoveryRequestPayload = {}

const parsedPayload = parseSchema('match-access-recovery-request', matchAccessRecoveryRequestPayload)

console.log(parsedPayload)

match-access-recovery-request: MatchAccessRecoveryRequest

Defined in: packages/ts-sdk/src/validators.ts:229

---

match-access-recovery-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchAccessRecoveryResponsePayload = {}

const parsedPayload = parseSchema('match-access-recovery-response', matchAccessRecoveryResponsePayload)

console.log(parsedPayload)

match-access-recovery-response: MatchAccessRecoveryResponse

Defined in: packages/ts-sdk/src/validators.ts:230

---

match-access-response

Example:

import { createSimulatorClient, parseSchema } from '@my-swu/simulator-client'

const simulatorClient = createSimulatorClient({
  baseUrl: 'http://127.0.0.1:4000',
})

// Use card ids; the server validates deck legality.
const premierHostDeck = {
  leader: 46102, // Leia Organa - Someone Who Loves You
  leaders: [], // Twin Suns only; Premier uses the single `leader` above.
  base: 308, // Echo Base
  cards: Array.from({ length: 50 }, () => 45), // Alliance X-Wing
  sideboard: [],
}

const matchAccess = await simulatorClient.matches.create({
  format: 'premier',
  // Twin Suns supports 2-4 players; every other format is exactly 2.
  playerCount: 2,
  hostName: 'Host',
  hostAuthenticated: false,
  historyIdentities: [],
  // One entry per AI-controlled seat; empty means a human opponent joins.
  aiOpponents: [],
  hostDeck: premierHostDeck,
})

const parsedPayload = parseSchema('match-access-response', matchAccess)

console.log(parsedPayload)

match-access-response: MatchAccessResponse

Defined in: packages/ts-sdk/src/validators.ts:210

---

match-chat-lookup-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchChatLookupResponsePayload = {}

const parsedPayload = parseSchema('match-chat-lookup-response', matchChatLookupResponsePayload)

console.log(parsedPayload)

match-chat-lookup-response: MatchChatLookupResponse

Defined in: packages/ts-sdk/src/validators.ts:211

---

match-connection-role

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchConnectionRolePayload = {}

const parsedPayload = parseSchema('match-connection-role', matchConnectionRolePayload)

console.log(parsedPayload)

match-connection-role: MatchConnectionRole

Defined in: packages/ts-sdk/src/validators.ts:212

---

match-history-deck-stats-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryDeckStatsRequestPayload = {}

const parsedPayload = parseSchema('match-history-deck-stats-request', matchHistoryDeckStatsRequestPayload)

console.log(parsedPayload)

match-history-deck-stats-request: MatchHistoryDeckStatsRequest

Defined in: packages/ts-sdk/src/validators.ts:213

---

match-history-deck-stats-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryDeckStatsResponsePayload = {}

const parsedPayload = parseSchema('match-history-deck-stats-response', matchHistoryDeckStatsResponsePayload)

console.log(parsedPayload)

match-history-deck-stats-response: MatchHistoryDeckStatsResponse

Defined in: packages/ts-sdk/src/validators.ts:214

---

match-history-entry

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryEntryPayload = {}

const parsedPayload = parseSchema('match-history-entry', matchHistoryEntryPayload)

console.log(parsedPayload)

match-history-entry: MatchHistoryEntry

Defined in: packages/ts-sdk/src/validators.ts:215

---

match-history-list-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryListRequestPayload = {}

const parsedPayload = parseSchema('match-history-list-request', matchHistoryListRequestPayload)

console.log(parsedPayload)

match-history-list-request: MatchHistoryListRequest

Defined in: packages/ts-sdk/src/validators.ts:216

---

match-history-list-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryListResponsePayload = {}

const parsedPayload = parseSchema('match-history-list-response', matchHistoryListResponsePayload)

console.log(parsedPayload)

match-history-list-response: MatchHistoryListResponse

Defined in: packages/ts-sdk/src/validators.ts:217

---

match-history-replay-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryReplayRequestPayload = {}

const parsedPayload = parseSchema('match-history-replay-request', matchHistoryReplayRequestPayload)

console.log(parsedPayload)

match-history-replay-request: MatchHistoryReplayRequest

Defined in: packages/ts-sdk/src/validators.ts:218

---

match-history-replay-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryReplayResponsePayload = {}

const parsedPayload = parseSchema('match-history-replay-response', matchHistoryReplayResponsePayload)

console.log(parsedPayload)

match-history-replay-response: MatchHistoryReplayResponse

Defined in: packages/ts-sdk/src/validators.ts:219

---

match-history-restore-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchHistoryRestoreRequestPayload = {}

const parsedPayload = parseSchema('match-history-restore-request', matchHistoryRestoreRequestPayload)

console.log(parsedPayload)

match-history-restore-request: MatchHistoryRestoreRequest

Defined in: packages/ts-sdk/src/validators.ts:223

---

match-recovery-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchRecoveryRequestPayload = {}

const parsedPayload = parseSchema('match-recovery-request', matchRecoveryRequestPayload)

console.log(parsedPayload)

match-recovery-request: MatchRecoveryRequest

Defined in: packages/ts-sdk/src/validators.ts:227

---

match-recovery-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchRecoveryResponsePayload = {}

const parsedPayload = parseSchema('match-recovery-response', matchRecoveryResponsePayload)

console.log(parsedPayload)

match-recovery-response: MatchRecoveryResponse

Defined in: packages/ts-sdk/src/validators.ts:228

---

match-save-payload

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchSavePayloadPayload = {}

const parsedPayload = parseSchema('match-save-payload', matchSavePayloadPayload)

console.log(parsedPayload)

match-save-payload: MatchSavePayload

Defined in: packages/ts-sdk/src/validators.ts:231

---

match-spectator-access-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const matchSpectatorAccessResponsePayload = {}

const parsedPayload = parseSchema('match-spectator-access-response', matchSpectatorAccessResponsePayload)

console.log(parsedPayload)

match-spectator-access-response: MatchSpectatorAccessResponse

Defined in: packages/ts-sdk/src/validators.ts:233

---

meta-window

Example:

import { parseSchema } from '@my-swu/simulator-client'

const metaWindowPayload = {}

const parsedPayload = parseSchema('meta-window', metaWindowPayload)

console.log(parsedPayload)

meta-window: MetaWindow

Defined in: packages/ts-sdk/src/validators.ts:234

---

meta-windows-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const metaWindowsResponsePayload = {}

const parsedPayload = parseSchema('meta-windows-response', metaWindowsResponsePayload)

console.log(parsedPayload)

meta-windows-response: MetaWindowsResponse

Defined in: packages/ts-sdk/src/validators.ts:235

---

playground-export-payload

Example:

import { parseSchema } from '@my-swu/simulator-client'

const playgroundExportPayloadPayload = {}

const parsedPayload = parseSchema('playground-export-payload', playgroundExportPayloadPayload)

console.log(parsedPayload)

playground-export-payload: PlaygroundExportPayload

Defined in: packages/ts-sdk/src/validators.ts:257

---

prepare-lobby-limited-ai-decks-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const prepareLobbyLimitedAiDecksRequestPayload = {}

const parsedPayload = parseSchema('prepare-lobby-limited-ai-decks-request', prepareLobbyLimitedAiDecksRequestPayload)

console.log(parsedPayload)

prepare-lobby-limited-ai-decks-request: PrepareLobbyLimitedAiDecksRequest

Defined in: packages/ts-sdk/src/validators.ts:266

---

ranked-admin-status

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedAdminStatusPayload = {}

const parsedPayload = parseSchema('ranked-admin-status', rankedAdminStatusPayload)

console.log(parsedPayload)

ranked-admin-status: RankedAdminStatus

Defined in: packages/ts-sdk/src/validators.ts:239

---

ranked-leaderboard-entry

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedLeaderboardEntryPayload = {}

const parsedPayload = parseSchema('ranked-leaderboard-entry', rankedLeaderboardEntryPayload)

console.log(parsedPayload)

ranked-leaderboard-entry: RankedLeaderboardEntry

Defined in: packages/ts-sdk/src/validators.ts:240

---

ranked-leaderboard-query

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedLeaderboardQueryPayload = {}

const parsedPayload = parseSchema('ranked-leaderboard-query', rankedLeaderboardQueryPayload)

console.log(parsedPayload)

ranked-leaderboard-query: RankedLeaderboardQuery

Defined in: packages/ts-sdk/src/validators.ts:241

---

ranked-leaderboard-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedLeaderboardResponsePayload = {}

const parsedPayload = parseSchema('ranked-leaderboard-response', rankedLeaderboardResponsePayload)

console.log(parsedPayload)

ranked-leaderboard-response: RankedLeaderboardResponse

Defined in: packages/ts-sdk/src/validators.ts:242

---

ranked-matchmaking-view

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedMatchmakingViewPayload = {}

const parsedPayload = parseSchema('ranked-matchmaking-view', rankedMatchmakingViewPayload)

console.log(parsedPayload)

ranked-matchmaking-view: RankedMatchmakingView

Defined in: packages/ts-sdk/src/validators.ts:243

---

ranked-profile-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedProfileRequestPayload = {}

const parsedPayload = parseSchema('ranked-profile-request', rankedProfileRequestPayload)

console.log(parsedPayload)

ranked-profile-request: RankedProfileRequest

Defined in: packages/ts-sdk/src/validators.ts:244

---

ranked-profile-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedProfileResponsePayload = {}

const parsedPayload = parseSchema('ranked-profile-response', rankedProfileResponsePayload)

console.log(parsedPayload)

ranked-profile-response: RankedProfileResponse

Defined in: packages/ts-sdk/src/validators.ts:245

---

ranked-queue

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rankedQueuePayload = {}

const parsedPayload = parseSchema('ranked-queue', rankedQueuePayload)

console.log(parsedPayload)

ranked-queue: "premierDuel"

Defined in: packages/ts-sdk/src/validators.ts:246

---

rematch-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rematchMatchRequestPayload = {}

const parsedPayload = parseSchema('rematch-match-request', rematchMatchRequestPayload)

console.log(parsedPayload)

rematch-match-request: RematchMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:247

---

rematch-match-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const rematchMatchResponsePayload = {}

const parsedPayload = parseSchema('rematch-match-response', rematchMatchResponsePayload)

console.log(parsedPayload)

rematch-match-response: RematchMatchResponse

Defined in: packages/ts-sdk/src/validators.ts:248

---

resolve-card-ids-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const resolveCardIdsRequestPayload = {
  references: [{
    setCode: 'SOR',
    cardNumber: 1,
    cardTypes: [
      'leader',
    ],
  }],
}

const parsedPayload = parseSchema('resolve-card-ids-request', resolveCardIdsRequestPayload)

console.log(parsedPayload)

resolve-card-ids-request: ResolveCardIdsRequest

Defined in: packages/ts-sdk/src/validators.ts:237

---

resolve-card-ids-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const resolveCardIdsResponsePayload = {
  resolutions: [{
    reference: {
      setCode: 'SOR',
      cardNumber: 1,
      cardTypes: [
        'leader',
      ],
    },
    cardId: 60,
    matches: [{
      cardId: 60,
      cardType: 'leader',
      title: 'Director Krennic',
    }],
  }],
}

const parsedPayload = parseSchema('resolve-card-ids-response', resolveCardIdsResponsePayload)

console.log(parsedPayload)

resolve-card-ids-response: ResolveCardIdsResponse

Defined in: packages/ts-sdk/src/validators.ts:238

---

restore-history-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const restoreHistoryResponsePayload = {}

const parsedPayload = parseSchema('restore-history-response', restoreHistoryResponsePayload)

console.log(parsedPayload)

restore-history-response: RestoreHistoryResponse

Defined in: packages/ts-sdk/src/validators.ts:226

---

restore-match-save-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const restoreMatchSaveRequestPayload = {}

const parsedPayload = parseSchema('restore-match-save-request', restoreMatchSaveRequestPayload)

console.log(parsedPayload)

restore-match-save-request: RestoreMatchSaveRequest

Defined in: packages/ts-sdk/src/validators.ts:251

---

restore-match-save-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const restoreMatchSaveResponsePayload = {}

const parsedPayload = parseSchema('restore-match-save-response', restoreMatchSaveResponsePayload)

console.log(parsedPayload)

restore-match-save-response: RestoreMatchSaveResponse

Defined in: packages/ts-sdk/src/validators.ts:252

---

return-lobby-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const returnLobbyMatchRequestPayload = {}

const parsedPayload = parseSchema('return-lobby-match-request', returnLobbyMatchRequestPayload)

console.log(parsedPayload)

return-lobby-match-request: ReturnLobbyMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:249

---

return-tournament-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const returnTournamentMatchRequestPayload = {}

const parsedPayload = parseSchema('return-tournament-match-request', returnTournamentMatchRequestPayload)

console.log(parsedPayload)

return-tournament-match-request: ReturnTournamentMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:250

---

save-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const saveMatchRequestPayload = {}

const parsedPayload = parseSchema('save-match-request', saveMatchRequestPayload)

console.log(parsedPayload)

save-match-request: SaveMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:232

---

server-message

Example:

import { parseSchema } from '@my-swu/simulator-client'

const serverMessagePayload = { type: 'pong', payload: { nonce: 'host-latency-1' } }

const parsedPayload = parseSchema('server-message', serverMessagePayload)

console.log(parsedPayload)

server-message: ServerMessage

Defined in: packages/ts-sdk/src/validators.ts:253

---

set-ai-paused-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const setAiPausedRequestPayload = {}

const parsedPayload = parseSchema('set-ai-paused-request', setAiPausedRequestPayload)

console.log(parsedPayload)

set-ai-paused-request: SetAiPausedRequest

Defined in: packages/ts-sdk/src/validators.ts:254

---

set-ai-paused-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const setAiPausedResponsePayload = {}

const parsedPayload = parseSchema('set-ai-paused-response', setAiPausedResponsePayload)

console.log(parsedPayload)

set-ai-paused-response: AiStatusPayload

Defined in: packages/ts-sdk/src/validators.ts:255

---

set-playground-ai-seat-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const setPlaygroundAiSeatRequestPayload = {}

const parsedPayload = parseSchema('set-playground-ai-seat-request', setPlaygroundAiSeatRequestPayload)

console.log(parsedPayload)

set-playground-ai-seat-request: SetPlaygroundAiSeatRequest

Defined in: packages/ts-sdk/src/validators.ts:256

---

set-ranked-admission-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const setRankedAdmissionRequestPayload = {}

const parsedPayload = parseSchema('set-ranked-admission-request', setRankedAdmissionRequestPayload)

console.log(parsedPayload)

set-ranked-admission-request: SetRankedAdmissionRequest

Defined in: packages/ts-sdk/src/validators.ts:259

---

set-simulator-maintenance-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const setSimulatorMaintenanceRequestPayload = {}

const parsedPayload = parseSchema('set-simulator-maintenance-request', setSimulatorMaintenanceRequestPayload)

console.log(parsedPayload)

set-simulator-maintenance-request: SetSimulatorMaintenanceRequest

Defined in: packages/ts-sdk/src/validators.ts:260

---

shared-match-history-replay-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const sharedMatchHistoryReplayResponsePayload = {}

const parsedPayload = parseSchema('shared-match-history-replay-response', sharedMatchHistoryReplayResponsePayload)

console.log(parsedPayload)

shared-match-history-replay-response: SharedMatchHistoryReplayResponse

Defined in: packages/ts-sdk/src/validators.ts:222

---

simulator-admin-status-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const simulatorAdminStatusResponsePayload = {}

const parsedPayload = parseSchema('simulator-admin-status-response', simulatorAdminStatusResponsePayload)

console.log(parsedPayload)

simulator-admin-status-response: SimulatorAdminStatusResponse

Defined in: packages/ts-sdk/src/validators.ts:261

---

simulator-availability-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const simulatorAvailabilityResponsePayload = {}

const parsedPayload = parseSchema('simulator-availability-response', simulatorAvailabilityResponsePayload)

console.log(parsedPayload)

simulator-availability-response: SimulatorAvailabilityResponse

Defined in: packages/ts-sdk/src/validators.ts:262

---

simulator-report-list-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const simulatorReportListResponsePayload = {}

const parsedPayload = parseSchema('simulator-report-list-response', simulatorReportListResponsePayload)

console.log(parsedPayload)

simulator-report-list-response: SimulatorReportListResponse

Defined in: packages/ts-sdk/src/validators.ts:157

---

simulator-report-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const simulatorReportResponsePayload = {}

const parsedPayload = parseSchema('simulator-report-response', simulatorReportResponsePayload)

console.log(parsedPayload)

simulator-report-response: SimulatorReportResponse

Defined in: packages/ts-sdk/src/validators.ts:158

---

spectate-lobby-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const spectateLobbyRequestPayload = {}

const parsedPayload = parseSchema('spectate-lobby-request', spectateLobbyRequestPayload)

console.log(parsedPayload)

spectate-lobby-request: SpectateLobbyRequest

Defined in: packages/ts-sdk/src/validators.ts:263

---

spectate-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const spectateMatchRequestPayload = {}

const parsedPayload = parseSchema('spectate-match-request', spectateMatchRequestPayload)

console.log(parsedPayload)

spectate-match-request: SpectateMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:264

---

start-lobby-limited-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const startLobbyLimitedMatchRequestPayload = {}

const parsedPayload = parseSchema('start-lobby-limited-match-request', startLobbyLimitedMatchRequestPayload)

console.log(parsedPayload)

start-lobby-limited-match-request: StartLobbyLimitedMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:265

---

start-lobby-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const startLobbyRequestPayload = {}

const parsedPayload = parseSchema('start-lobby-request', startLobbyRequestPayload)

console.log(parsedPayload)

start-lobby-request: StartLobbyRequest

Defined in: packages/ts-sdk/src/validators.ts:267

---

start-tournament-event-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const startTournamentEventRequestPayload = {}

const parsedPayload = parseSchema('start-tournament-event-request', startTournamentEventRequestPayload)

console.log(parsedPayload)

start-tournament-event-request: StartTournamentEventRequest

Defined in: packages/ts-sdk/src/validators.ts:268

---

submit-ai-game-feedback-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const submitAiGameFeedbackRequestPayload = {}

const parsedPayload = parseSchema('submit-ai-game-feedback-request', submitAiGameFeedbackRequestPayload)

console.log(parsedPayload)

submit-ai-game-feedback-request: SubmitAiGameFeedbackRequest

Defined in: packages/ts-sdk/src/validators.ts:224

---

submit-ai-game-feedback-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const submitAiGameFeedbackResponsePayload = {}

const parsedPayload = parseSchema('submit-ai-game-feedback-response', submitAiGameFeedbackResponsePayload)

console.log(parsedPayload)

submit-ai-game-feedback-response: SubmitAiGameFeedbackResponse

Defined in: packages/ts-sdk/src/validators.ts:225

---

submit-lobby-limited-deck-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const submitLobbyLimitedDeckRequestPayload = {}

const parsedPayload = parseSchema('submit-lobby-limited-deck-request', submitLobbyLimitedDeckRequestPayload)

console.log(parsedPayload)

submit-lobby-limited-deck-request: SubmitLobbyLimitedDeckRequest

Defined in: packages/ts-sdk/src/validators.ts:269

---

submit-match-deck-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const submitMatchDeckRequestPayload = {}

const parsedPayload = parseSchema('submit-match-deck-request', submitMatchDeckRequestPayload)

console.log(parsedPayload)

submit-match-deck-request: SubmitMatchDeckRequest

Defined in: packages/ts-sdk/src/validators.ts:270

---

submit-match-deck-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const submitMatchDeckResponsePayload = {}

const parsedPayload = parseSchema('submit-match-deck-response', submitMatchDeckResponsePayload)

console.log(parsedPayload)

submit-match-deck-response: SubmitMatchDeckResponse

Defined in: packages/ts-sdk/src/validators.ts:271

---

submit-tournament-deck-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const submitTournamentDeckRequestPayload = {}

const parsedPayload = parseSchema('submit-tournament-deck-request', submitTournamentDeckRequestPayload)

console.log(parsedPayload)

submit-tournament-deck-request: SubmitTournamentDeckRequest

Defined in: packages/ts-sdk/src/validators.ts:272

---

tournament-event-command-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentEventCommandRequestPayload = {}

const parsedPayload = parseSchema('tournament-event-command-request', tournamentEventCommandRequestPayload)

console.log(parsedPayload)

tournament-event-command-request: TournamentEventCommandRequest

Defined in: packages/ts-sdk/src/validators.ts:273

---

tournament-room-access-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomAccessResponsePayload = {}

const parsedPayload = parseSchema('tournament-room-access-response', tournamentRoomAccessResponsePayload)

console.log(parsedPayload)

tournament-room-access-response: TournamentRoomAccessResponse

Defined in: packages/ts-sdk/src/validators.ts:274

---

tournament-room-chat-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomChatRequestPayload = {}

const parsedPayload = parseSchema('tournament-room-chat-request', tournamentRoomChatRequestPayload)

console.log(parsedPayload)

tournament-room-chat-request: TournamentRoomChatRequest

Defined in: packages/ts-sdk/src/validators.ts:275

---

tournament-room-chat-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomChatResponsePayload = {}

const parsedPayload = parseSchema('tournament-room-chat-response', tournamentRoomChatResponsePayload)

console.log(parsedPayload)

tournament-room-chat-response: TournamentRoomChatResponse

Defined in: packages/ts-sdk/src/validators.ts:276

---

tournament-room-list-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomListResponsePayload = {}

const parsedPayload = parseSchema('tournament-room-list-response', tournamentRoomListResponsePayload)

console.log(parsedPayload)

tournament-room-list-response: TournamentRoomListResponse

Defined in: packages/ts-sdk/src/validators.ts:277

---

tournament-room-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomResponsePayload = {}

const parsedPayload = parseSchema('tournament-room-response', tournamentRoomResponsePayload)

console.log(parsedPayload)

tournament-room-response: TournamentRoomResponse

Defined in: packages/ts-sdk/src/validators.ts:278

---

tournament-room-server-message

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomServerMessagePayload = {}

const parsedPayload = parseSchema('tournament-room-server-message', tournamentRoomServerMessagePayload)

console.log(parsedPayload)

tournament-room-server-message: TournamentRoomServerMessage

Defined in: packages/ts-sdk/src/validators.ts:279

---

tournament-room-sync-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const tournamentRoomSyncRequestPayload = {}

const parsedPayload = parseSchema('tournament-room-sync-request', tournamentRoomSyncRequestPayload)

console.log(parsedPayload)

tournament-room-sync-request: TournamentRoomSyncRequest

Defined in: packages/ts-sdk/src/validators.ts:280

---

undo-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const undoMatchRequestPayload = {}

const parsedPayload = parseSchema('undo-match-request', undoMatchRequestPayload)

console.log(parsedPayload)

undo-match-request: UndoMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:281

---

undo-match-response

Example:

import { parseSchema } from '@my-swu/simulator-client'

const undoMatchResponsePayload = {}

const parsedPayload = parseSchema('undo-match-response', undoMatchResponsePayload)

console.log(parsedPayload)

undo-match-response: UndoMatchResponse

Defined in: packages/ts-sdk/src/validators.ts:282

---

undo-respond-match-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const undoRespondMatchRequestPayload = {}

const parsedPayload = parseSchema('undo-respond-match-request', undoRespondMatchRequestPayload)

console.log(parsedPayload)

undo-respond-match-request: UndoRespondMatchRequest

Defined in: packages/ts-sdk/src/validators.ts:283

---

update-lobby-ai-player-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const updateLobbyAiPlayerRequestPayload = {}

const parsedPayload = parseSchema('update-lobby-ai-player-request', updateLobbyAiPlayerRequestPayload)

console.log(parsedPayload)

update-lobby-ai-player-request: UpdateLobbyAiPlayerRequest

Defined in: packages/ts-sdk/src/validators.ts:284

---

update-lobby-player-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const updateLobbyPlayerRequestPayload = {}

const parsedPayload = parseSchema('update-lobby-player-request', updateLobbyPlayerRequestPayload)

console.log(parsedPayload)

update-lobby-player-request: UpdateLobbyPlayerRequest

Defined in: packages/ts-sdk/src/validators.ts:285

---

update-lobby-settings-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const updateLobbySettingsRequestPayload = {}

const parsedPayload = parseSchema('update-lobby-settings-request', updateLobbySettingsRequestPayload)

console.log(parsedPayload)

update-lobby-settings-request: UpdateLobbySettingsRequest

Defined in: packages/ts-sdk/src/validators.ts:286

---

update-tournament-room-player-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const updateTournamentRoomPlayerRequestPayload = {}

const parsedPayload = parseSchema('update-tournament-room-player-request', updateTournamentRoomPlayerRequestPayload)

console.log(parsedPayload)

update-tournament-room-player-request: UpdateTournamentRoomPlayerRequest

Defined in: packages/ts-sdk/src/validators.ts:287

---

update-tournament-room-settings-request

Example:

import { parseSchema } from '@my-swu/simulator-client'

const updateTournamentRoomSettingsRequestPayload = {}

const parsedPayload = parseSchema('update-tournament-room-settings-request', updateTournamentRoomSettingsRequestPayload)

console.log(parsedPayload)

update-tournament-room-settings-request: UpdateTournamentRoomSettingsRequest

Defined in: packages/ts-sdk/src/validators.ts:288

---

welcome-payload

Example:

import { parseSchema } from '@my-swu/simulator-client'

const welcomePayloadPayload = { matchId: 'match_123', role: 'player', seat: 'one' }

const parsedPayload = parseSchema('welcome-payload', welcomePayloadPayload)

console.log(parsedPayload)

welcome-payload: WelcomePayload

Defined in: packages/ts-sdk/src/validators.ts:289