@my-swu/simulator-client 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Guillaume Chau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,355 @@
+# @my-swu/simulator-client
+
+Typed TypeScript SDK for the `swu-simulator` HTTP and WebSocket engine.
+
+The SDK ships generated protocol types from the Rust server, validates runtime
+payloads at the network boundary, and exposes a small resource-based client for
+matches, card metadata, Limited Events, and system checks.
+
+## Install
+
+```bash
+pnpm add @my-swu/simulator-client
+```
+
+```bash
+npm install @my-swu/simulator-client
+```
+
+## Runtime Requirements
+
+- Node.js 18+ or a runtime with global `fetch`.
+- A browser-style `WebSocket` global for live match connections.
+- ESM only.
+
+Node has `fetch` but not a browser WebSocket global. Keep the SDK lean by
+injecting your socket implementation:
+
+```ts
+import WebSocket from 'ws'
+import { createSimulatorClient } from '@my-swu/simulator-client'
+import type { WebSocketFactory } from '@my-swu/simulator-client'
+
+// Node examples use `ws` to provide the browser-compatible socket shape.
+const nodeWebSocketFactory: WebSocketFactory = url => new WebSocket(url)
+
+const simulatorClient = createSimulatorClient({
+  baseUrl: 'http://127.0.0.1:4000',
+  // Required only for live match sockets in runtimes without global WebSocket.
+  webSocketFactory: nodeWebSocketFactory,
+})
+```
+
+## Card ids
+
+Decks and commands use card ids. These are not collector numbers or
+match-local `unitId` / `abilityId` handles. The
+examples below use `46102` for Leia Organa - Someone Who Loves You, `46107` for
+Darth Vader - Unstoppable, `308` for Echo Base, `309` for Tarkintown, `45` for
+Alliance X-Wing, and `35` for TIE/ln Fighter.
+
+Convert set code plus printed card number into card ids through the card
+resource:
+
+```ts
+const krennicCardId = await simulatorClient.cards.resolveId({
+  setCode: 'SOR',
+  cardNumber: 1,
+  cardTypes: ['leader'],
+})
+```
+
+Import my-swu JSON decks with `SET_001` card ids before match creation:
+
+```ts
+const importedDeck = await simulatorClient.cards.convertDeckJson({
+  leader: { id: 'SOR_001', count: 1 },
+  base: { id: 'SOR_025', count: 1 },
+  deck: [{ id: 'SOR_010', count: 3 }],
+})
+
+await simulatorClient.matches.create({
+  format: 'premier',
+  playerCount: 2,
+  hostDeck: importedDeck,
+  hostName: 'Host',
+  hostAuthenticated: false,
+  historyIdentities: [],
+  aiOpponents: [],
+})
+```
+
+## Quick Match
+
+```ts
+import { createSimulatorClient } from '@my-swu/simulator-client'
+
+const simulatorClient = createSimulatorClient({
+  baseUrl: 'http://127.0.0.1:4000',
+})
+
+// Use card ids; these example card ids map to real cards.
+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 hostAccess = await simulatorClient.matches.create({
+  // Seeds make local examples and tests deterministic.
+  seed: 7,
+  format: 'premier',
+  // Twin Suns supports 2-4 players; every other format is exactly 2.
+  playerCount: 2,
+  hostDeck: premierHostDeck,
+  hostName: 'Host',
+  hostAuthenticated: false,
+  historyIdentities: [],
+  // One entry per AI-controlled seat; empty means a human opponent joins.
+  aiOpponents: [],
+})
+
+// The session stores matchId plus the private seat token for this seat.
+const matchSession = simulatorClient.session.create(hostAccess)
+await matchSession.connect()
+
+matchSession.on('snapshot', matchSnapshot => {
+  // Render from snapshots; they are the authoritative game state.
+  console.log(matchSnapshot.prompt)
+})
+
+// Both seats must be ready before setup can advance.
+matchSession.ready()
+```
+
+## Resource API
+
+```ts
+// System health checks are cheap liveness checks.
+const health = await simulatorClient.system.health()
+
+// Card resources read canonical card metadata from the simulator server cache.
+const requestedCardMetadata = await simulatorClient.cards.get([
+  46102, // Leia Organa - Someone Who Loves You
+  308, // Echo Base
+])
+const catalogCards = await simulatorClient.cards.catalog()
+
+// Match creation validates decks before allocating seat credentials.
+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 premierGuestDeck = {
+  leader: 46107, // Darth Vader - Unstoppable
+  leaders: [],
+  base: 309, // Tarkintown
+  cards: Array.from({ length: 50 }, () => 35), // TIE/ln Fighter
+  sideboard: [],
+}
+
+const hostAccess = await simulatorClient.matches.create({
+  format: 'premier',
+  playerCount: 2,
+  hostDeck: premierHostDeck,
+  hostName: 'Host',
+  hostAuthenticated: false,
+  historyIdentities: [],
+  aiOpponents: [],
+})
+const guestAccess = await simulatorClient.matches.join(hostAccess, {
+  deck: premierGuestDeck,
+  name: 'Guest',
+  authenticated: false,
+  historyIdentities: [],
+})
+const publicMatchSnapshot = await simulatorClient.matches.get(hostAccess)
+const updatedMatchSnapshot = await simulatorClient.matches.applyFormatEvent(hostAccess, { type: 'readyNextGame' })
+
+// Limited Events produce draft or sealed pools before normal match creation.
+const draftEventAccess = await simulatorClient.limitedEvents.create({
+  kind: 'draft',
+  draftRounds: [],
+  pickTimerEnabled: false,
+  setCode: 'SOR',
+  playerCount: 4,
+})
+const draftSeatAccess = await simulatorClient.limitedEvents.join(draftEventAccess)
+const limitedEventSnapshot = await simulatorClient.limitedEvents.get(draftSeatAccess)
+const nextLimitedEventSnapshot = await simulatorClient.limitedEvents.applyCommand(
+  draftSeatAccess,
+  { type: 'readyForNextDraft' },
+)
+
+console.log(
+  health.status,
+  requestedCardMetadata.length,
+  catalogCards.length,
+  guestAccess.seat,
+  publicMatchSnapshot.status,
+  updatedMatchSnapshot.status,
+  limitedEventSnapshot.phase.kind,
+  nextLimitedEventSnapshot.phase.kind,
+)
+```
+
+## Cancellation and Timeouts
+
+Every HTTP resource method takes an optional trailing options argument with a
+caller-owned `signal` and a per-call `timeoutMs`. Omit it and nothing changes.
+
+```ts
+const unmountController = new AbortController()
+
+// Cancel in-flight work when the view goes away, and bound the wait.
+const publicMatchSnapshot = await simulatorClient.matches.get(hostAccess, {
+  signal: unmountController.signal,
+  timeoutMs: 5_000,
+})
+```
+
+`createSimulatorClient({ timeoutMs })` sets a default for every call. A per-call
+`timeoutMs` overrides it, and `0` opts a single call out of the default. When a
+signal and a timeout are both in play, whichever fires first wins.
+
+```ts
+import { createSimulatorClient } from '@my-swu/simulator-client'
+
+const boundedClient = createSimulatorClient({
+  baseUrl: 'http://127.0.0.1:4000',
+  timeoutMs: 10_000,
+})
+
+// The catalog is large; give this one call more room than the default.
+const catalogCards = await boundedClient.cards.catalog({ timeoutMs: 60_000 })
+```
+
+## Runtime Validation
+
+Runtime schema validation is **off by default**. Responses, request bodies and
+socket frames come back as their generated TypeScript types without being
+checked against the JSON schemas first.
+
+The reason is bundle size. The generated schema map plus Ajv are 90% of the
+minified SDK, and they are unreachable from `createSimulatorClient` unless you
+name `createSchemaValidator`:
+
+| Bundle | Minified | Gzip |
+| --- | --- | --- |
+| Default client | 39.1 KB | 9.9 KB |
+| `validate: createSchemaValidator()` | 478.2 KB | 102.0 KB |
+
+Measured with esbuild against `dist/index.js` for an entry that builds a client
+and one match session: 322 KB of generated schemas and 115 KB of Ajv drop out.
+Per frame, decoding a real 3.2 KB `server-message` snapshot costs about 5 µs
+with validation off (the `JSON.parse` floor) against 13-15 µs with it on, so
+validation adds 8-10 µs to every frame; each outbound envelope adds about
+0.9 µs.
+
+What you give up on the default:
+
+- A malformed server payload is not rejected. It reaches your code typed as if
+  it were valid, so the mismatch shows up later as an `undefined` field.
+- A malformed request body is not caught locally. You get the server's `400`
+  through `EngineHttpError` instead of an `SdkValidationError` naming the field.
+- An unknown server message type is no longer dropped during decode. It cannot
+  be mis-dispatched — no router has a case for it — but it does reach the raw
+  `message` event.
+
+Non-schema failures are unchanged: invalid JSON on a socket still emits
+`sdk_invalid_server_message`, and a non-2xx response still throws
+`EngineHttpError`.
+
+Pass a validator to get the previous behaviour back, everywhere:
+
+```ts
+import {
+  createSchemaValidator,
+  createSimulatorClient,
+} from '@my-swu/simulator-client'
+
+const validatingSimulatorClient = createSimulatorClient({
+  baseUrl: 'http://127.0.0.1:4000',
+  validate: createSchemaValidator(),
+})
+
+// Throws SdkValidationError if the server answers off-contract.
+const validatedHealth = await validatingSimulatorClient.system.health()
+```
+
+`parseSchema()` is unaffected: an explicit call always validates, whatever the
+client is configured to do.
+
+One validator serves the whole client: HTTP bodies and responses plus every
+socket it opens — match sessions, lobby sessions, the public lobby list, and
+tournament rooms all inherit it.
+
+Schema compilation is lazy and the first compile is by far the most expensive
+(~215 ms, because it pulls in the whole shared definition pool), so
+`createSimulatorClient` schedules the validator's `warmUp()` on an idle callback
+and gets it off the connect path — the first validated frame drops from 226 ms
+to a 7.9 ms median. Nothing to configure, and with validation off it is a real
+no-op: the pass-through validator does not implement `warmUp`.
+
+## Match Session
+
+`simulatorClient.session.create(access)` accepts a returned match access object
+or any `{ matchId, seatToken }` value. `connect()` resolves after the socket
+opens, `welcome` arrives, and the first `snapshot` arrives.
+
+```ts
+const matchSession = simulatorClient.session.create(hostAccess, {
+  handshakeTimeoutMs: 10_000,
+})
+await matchSession.connect()
+
+// Wait helpers resolve immediately if the current snapshot already matches.
+await matchSession.waitForSnapshot(
+  matchSnapshot => typeof matchSnapshot.prompt === 'object' && 'chooseInitiative' in matchSnapshot.prompt,
+)
+
+// Reconnect keeps registered listeners and requests a fresh snapshot.
+await matchSession.reconnect({ handshakeTimeoutMs: 5_000 })
+```
+
+## Errors
+
+- `EngineHttpError` is thrown for non-2xx HTTP responses and includes `status`,
+  `code`, `method`, `url`, `payload`, and `responseText` when available.
+- `EngineRequestAbortedError` is thrown when an HTTP call is cancelled before the
+  server answers. `kind` is `'aborted'` for a caller-supplied signal and
+  `'timeout'` for an elapsed timeout.
+- `SdkValidationError` is thrown by `parseSchema()`, and — when the client is
+  built with `validate` — when a request or response does not match the
+  generated schema. See [Runtime Validation](#runtime-validation).
+- Socket decode failures emit an `error` event with
+  `code: 'sdk_invalid_server_message'`. Match, lobby, tournament-room, and
+  lobby-list sockets share one decoder, so all four report invalid JSON and
+  (with a validator) malformed known frames the same way, and all four ignore an
+  unknown frame `type` so the wire can grow.
+
+## Schemas and Types
+
+- Public protocol types are exported from the package root and
+  `@my-swu/simulator-client/generated`.
+- The root export set is closed under reference: if an exported type names
+  another generated type in one of its fields, that one is exported too. Import
+  nested wire views by name instead of rebuilding them with indexed access.
+- JSON schemas are published under `@my-swu/simulator-client/schema/*`.
+- Shared definitions live once in `schema/common.schema.json`; every root schema
+  references them by its `$id`
+  (`https://simulator-sdk.my-swu.com/schema/common.json`) instead of inlining a
+  copy. Register that document with your validator before the roots, the way
+  `parseSchema` does — for Ajv, `ajv.addSchema(sdkSchemaCommon)` first.
+- `schema/manifest.json` lists the roots in `files` and the shared document in
+  `shared`.
+
+## License
+
+MIT

package/dist/actionable.d.ts

@@ -0,0 +1,61 @@
+import type { GameCommand, GameState } from './generated/index.js';
+import type { AbilityTarget, ActionAbilityView, LeaderActionView, LeaderDeployActionView, PendingAbilityView, PlayActionView, TargetSelectionGroup } from './types.js';
+/**
+ * Every projected action that asks the player to pick targets.
+ *
+ * The engine splits these across two field names: `PendingAbilityView` nests
+ * its groups in `targetPlan`, while the three action views keep `targetGroups`
+ * inline. Walking both is what {@link targetGroupsOf} exists for.
+ */
+export type TargetingActionView = ActionAbilityView | LeaderActionView | PendingAbilityView | PlayActionView;
+/**
+ * Reads the ordered target-selection groups of any targeting action.
+ *
+ * Hides the `targetPlan` / `targetGroups` split so a consumer that renders
+ * pending abilities and playable actions through one code path does not need
+ * its own accessor.
+ *
+ * @param action Projected action, or a nullish value while none is selected.
+ * @returns The action's groups in engine order; empty when there is no action.
+ */
+export declare function targetGroupsOf(action: TargetingActionView | null | undefined): TargetSelectionGroup[];
+/**
+ * Concatenates every group's candidate targets, in group order.
+ *
+ * This is what the retired flat `validTargets` field on the action views
+ * carried, so "how many targets could this action pick from?" stays a
+ * one-liner. Duplicates are kept: one entity legal in two groups appears
+ * twice, matching the retired field.
+ *
+ * @param groups Groups from {@link targetGroupsOf}, or a nullish value.
+ * @returns Every candidate target across the groups.
+ */
+export declare function flattenTargetGroups(groups: readonly TargetSelectionGroup[] | null | undefined): AbilityTarget[];
+/**
+ * Whether a plan is exactly one mandatory pick.
+ *
+ * That is the shape the engine synthesises for an ability with no structured
+ * clauses but with candidate targets, and it is the only plan a client can
+ * resolve from a single selection: one group, `min` and `max` both 1. An
+ * optional pick (`min: 0`) or a multi-target group still needs an explicit
+ * submit step.
+ *
+ * @param groups Groups from {@link targetGroupsOf}, or a nullish value.
+ */
+export declare function isSingleTargetPlan(groups: readonly TargetSelectionGroup[] | null | undefined): boolean;
+/**
+ * Returns whether the snapshot exposes at least one legal leader deploy action.
+ */
+export declare function canDeployAnyLeader(snapshot: GameState): boolean;
+/**
+ * Returns unique leader slot indices that have at least one legal deploy action.
+ */
+export declare function getDeployableLeaderIndices(snapshot: GameState): number[];
+/**
+ * Builds the gameplay command for one projected leader deploy action.
+ */
+export declare function leaderDeployCommand(action: LeaderDeployActionView): GameCommand;
+/**
+ * Builds gameplay commands for every projected leader deploy action.
+ */
+export declare function getLeaderDeployCommands(snapshot: GameState): GameCommand[];

package/dist/actionable.js

@@ -0,0 +1,91 @@
+/**
+ * Reads the ordered target-selection groups of any targeting action.
+ *
+ * Hides the `targetPlan` / `targetGroups` split so a consumer that renders
+ * pending abilities and playable actions through one code path does not need
+ * its own accessor.
+ *
+ * @param action Projected action, or a nullish value while none is selected.
+ * @returns The action's groups in engine order; empty when there is no action.
+ */
+export function targetGroupsOf(action) {
+    if (action == null)
+        return [];
+    // `targetPlan` is the structural discriminator between the two shapes: only
+    // `PendingAbilityView` carries it, and it is always present when it does.
+    return 'targetPlan' in action ? action.targetPlan.groups : action.targetGroups;
+}
+/**
+ * Concatenates every group's candidate targets, in group order.
+ *
+ * This is what the retired flat `validTargets` field on the action views
+ * carried, so "how many targets could this action pick from?" stays a
+ * one-liner. Duplicates are kept: one entity legal in two groups appears
+ * twice, matching the retired field.
+ *
+ * @param groups Groups from {@link targetGroupsOf}, or a nullish value.
+ * @returns Every candidate target across the groups.
+ */
+export function flattenTargetGroups(groups) {
+    return (groups ?? []).flatMap((group) => group.validTargets);
+}
+/**
+ * Whether a plan is exactly one mandatory pick.
+ *
+ * That is the shape the engine synthesises for an ability with no structured
+ * clauses but with candidate targets, and it is the only plan a client can
+ * resolve from a single selection: one group, `min` and `max` both 1. An
+ * optional pick (`min: 0`) or a multi-target group still needs an explicit
+ * submit step.
+ *
+ * @param groups Groups from {@link targetGroupsOf}, or a nullish value.
+ */
+export function isSingleTargetPlan(groups) {
+    if ((groups?.length ?? 0) !== 1)
+        return false;
+    const group = groups?.[0];
+    return group?.min === 1 && group.max === 1;
+}
+/**
+ * Returns whether the snapshot exposes at least one legal leader deploy action.
+ */
+export function canDeployAnyLeader(snapshot) {
+    return (snapshot.availableLeaderDeploys ?? []).length > 0;
+}
+/**
+ * Returns unique leader slot indices that have at least one legal deploy action.
+ */
+export function getDeployableLeaderIndices(snapshot) {
+    const indices = new Set();
+    for (const action of snapshot.availableLeaderDeploys ?? []) {
+        indices.add(action.leaderIndex);
+    }
+    return [...indices];
+}
+/**
+ * Builds the gameplay command for one projected leader deploy action.
+ */
+export function leaderDeployCommand(action) {
+    if (action.mode === 'unit') {
+        return action.leaderIndex === 0
+            ? 'deployLeader'
+            : { deployLeaderByIndex: { leaderIndex: action.leaderIndex } };
+    }
+    if (action.attachedToUnitId == null) {
+        throw new Error('pilot leader deploy action is missing attachedToUnitId');
+    }
+    return action.leaderIndex === 0
+        ? { deployLeaderAsPilot: { attachedToUnitId: action.attachedToUnitId } }
+        : {
+            deployLeaderAsPilotByIndex: {
+                attachedToUnitId: action.attachedToUnitId,
+                leaderIndex: action.leaderIndex,
+            },
+        };
+}
+/**
+ * Builds gameplay commands for every projected leader deploy action.
+ */
+export function getLeaderDeployCommands(snapshot) {
+    return (snapshot.availableLeaderDeploys ?? []).map(leaderDeployCommand);
+}

package/dist/client.d.ts

@@ -0,0 +1,157 @@
+import type { FetchLike, WebSocketFactory } from './internal/transport.js';
+import type { AdminResource } from './resources/admin.js';
+import type { CardsResource } from './resources/card-resource.js';
+import type { LimitedEventsResource } from './resources/limited-events.js';
+import type { LobbiesResource } from './resources/lobbies.js';
+import type { MatchHistoryResource } from './resources/match-history.js';
+import type { MatchesResource } from './resources/matches.js';
+import type { SessionResource } from './resources/session.js';
+import type { SystemResource } from './resources/system.js';
+import type { TournamentRoomsResource } from './resources/tournament-rooms.js';
+import type { SchemaValidator } from './validators/validator.js';
+/**
+ * Constructor options for the simulator client.
+ *
+ * `baseUrl` points at the HTTP origin for the simulator server. The SDK derives
+ * `/api/*`, `/health`, and the matching `/ws` socket origin from this value.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ *
+ * console.log(await simulatorClient.system.health())
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/getting-started
+ * @see https://simulator-sdk.my-swu.com/guide/runtime-adapters
+ */
+export interface SimulatorClientOptions {
+    /**
+     * Base URL of the simulator HTTP API, for example `http://127.0.0.1:4000`.
+     * The trailing slash is optional.
+     */
+    baseUrl: string;
+    /**
+     * Optional fetch implementation. Defaults to the global `fetch` when available.
+     */
+    fetch?: FetchLike;
+    /**
+     * Optional default timeout, in milliseconds, for every HTTP resource call.
+     *
+     * A per-call `timeoutMs` overrides this value, and passing `0` for one call
+     * opts that call out. Leave it unset to keep requests unbounded, which is how
+     * the client behaved before timeouts existed.
+     */
+    timeoutMs?: number | undefined;
+    /**
+     * Optional runtime validator for every payload crossing the network boundary.
+     *
+     * Off by default: HTTP responses, HTTP request bodies and socket frames are
+     * trusted as-is. Pass `createSchemaValidator()` to check all of them against
+     * the generated schemas, which is what the SDK did unconditionally before
+     * this option existed.
+     *
+     * The default exists for bundle size: naming `createSchemaValidator` is what
+     * makes the generated schema map and Ajv reachable from this module, and they
+     * are about 90% of the SDK's minified weight. A custom implementation of
+     * {@link SchemaValidator} is accepted too.
+     *
+     * @example
+     * ```ts
+     * import { createSchemaValidator, createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     *   validate: createSchemaValidator(),
+     * })
+     * ```
+     */
+    validate?: SchemaValidator | undefined;
+    /**
+     * Optional WebSocket factory. Defaults to the global `WebSocket` when available.
+     */
+    webSocketFactory?: WebSocketFactory;
+}
+/**
+ * Public typed client used to call simulator HTTP and WebSocket APIs.
+ *
+ * The client groups endpoints by workflow: system checks, card metadata, match
+ * lifecycle calls, Limited Events, and high-level match sessions.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ *
+ * const health = await simulatorClient.system.health()
+ * const requestedCardMetadata = await simulatorClient.cards.get([46102])
+ * console.log(health.status, requestedCardMetadata[0]?.title)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/client-api
+ */
+export interface SimulatorClient {
+    /**
+     * Simulator administration APIs.
+     */
+    readonly admin: AdminResource;
+    /**
+     * Card metadata APIs.
+     */
+    readonly cards: CardsResource;
+    /**
+     * Limited Event APIs.
+     */
+    readonly limitedEvents: LimitedEventsResource;
+    /**
+     * Pre-match multiplayer lobby APIs.
+     */
+    readonly lobbies: LobbiesResource;
+    /**
+     * Server-owned simulator history APIs.
+     */
+    readonly matchHistory: MatchHistoryResource;
+    /**
+     * Match lifecycle APIs.
+     */
+    readonly matches: MatchesResource;
+    /**
+     * High-level live match session APIs.
+     */
+    readonly session: SessionResource;
+    /**
+     * System APIs.
+     */
+    readonly system: SystemResource;
+    /**
+     * Tournament room APIs for sealed/draft events and duel tables.
+     */
+    readonly tournamentRooms: TournamentRoomsResource;
+}
+/**
+ * Creates one typed simulator client.
+ *
+ * Use one client per simulator server origin. Payloads are returned as typed
+ * values without being checked at runtime; pass `validate` to have request
+ * bodies, responses and socket frames verified against the generated schemas.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ *
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/http-client
+ */
+export declare function createSimulatorClient(options: SimulatorClientOptions): SimulatorClient;