@my-swu/simulator-client 0.1.0

package/dist/match-session/types.d.ts

@@ -0,0 +1,56 @@
+import type { AiStatusPayload, ErrorPayload, GameEvent, GameState, WelcomePayload } from '../generated/index.js';
+import type { MatchHistoryFeedEntry } from '../generated/types/server-message.js';
+import type { ConnectionState } from '../session.js';
+import type { MatchSessionMethods } from './methods.js';
+import type { MatchSeat, MatchSessionReconnectState, MatchSessionState } from './session-state.js';
+export type { MatchSeat, MatchSessionAccess, MatchSessionAutoReconnectOptions, MatchSessionAutoReconnectPolicy, MatchSessionConnectOptions, MatchSessionEvents, MatchSessionOptions, MatchSessionReconnectState, MatchSessionSnapshotPredicate, MatchSessionState, MatchSessionWaitOptions, } from './session-state.js';
+/**
+ * Main ergonomic SDK API for interacting with one live match.
+ *
+ * A session wraps HTTP match creation/joining, WebSocket connection state,
+ * incoming snapshots/events, outgoing commands, and explicit reconnects for one
+ * private player seat.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ * const hostAccess = { matchId: 'match_123', seatToken: 'seat_token_123' }
+ *
+ * const matchSession = simulatorClient.session.create(hostAccess)
+ * await matchSession.connect()
+ * matchSession.ready()
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-session
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export interface MatchSession extends MatchSessionMethods {
+    /** Latest AI attachment/pause status announced by the server. */
+    readonly aiStatus: AiStatusPayload | undefined;
+    /** Current transport state. */
+    readonly connectionState: ConnectionState;
+    /** Recent engine or SDK errors. */
+    readonly errors: readonly ErrorPayload[];
+    /** Recent game events. */
+    readonly events: readonly GameEvent[];
+    /** Recent match history entries supplied by the server. */
+    readonly history: readonly MatchHistoryFeedEntry[];
+    /** Human-readable error summaries. */
+    readonly errorMessages: readonly string[];
+    /** Public match id when one is known. */
+    readonly matchId: string | undefined;
+    /** Automatic reconnect progress after an abnormal socket close. */
+    readonly reconnectState: MatchSessionReconnectState;
+    /** Latest authoritative private snapshot for this seat. */
+    readonly snapshot: GameState | undefined;
+    /** Seat controlled by this session when known. */
+    readonly seat: MatchSeat | undefined;
+    /** Token-free state snapshot. */
+    readonly state: MatchSessionState;
+    /** Latest welcome payload when the socket handshake has completed. */
+    readonly welcome: WelcomePayload | undefined;
+}

package/dist/match-session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/match-session.d.ts

@@ -0,0 +1,3 @@
+export { MatchSessionController } from './match-session/controller.js';
+export type { MatchSessionControllerOptions } from './match-session/controller.js';
+export type { MatchSeat, MatchSession, MatchSessionAccess, MatchSessionAutoReconnectOptions, MatchSessionAutoReconnectPolicy, MatchSessionConnectOptions, MatchSessionEvents, MatchSessionOptions, MatchSessionReconnectState, MatchSessionSnapshotPredicate, MatchSessionState, MatchSessionWaitOptions, } from './match-session/types.js';

package/dist/match-session.js

@@ -0,0 +1 @@
+export { MatchSessionController } from './match-session/controller.js';

package/dist/messages.d.ts

@@ -0,0 +1,195 @@
+import type { ClientMessage, GameCommand } from './generated/index.js';
+import type { CardInteractionCueRequest } from './generated/types/client-message.js';
+import type { FormatEventCommand } from './generated/types/format-event-request.js';
+/**
+ * Builds one `ready` socket message.
+ *
+ * Most apps call `matchSession.ready()` instead of constructing envelopes
+ * manually. Use this helper when you are working directly with socket frames.
+ *
+ * @example
+ * ```ts
+ * import { readyMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = readyMessage()
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export declare function readyMessage(): ClientMessage;
+/**
+ * Builds one `undo` socket message.
+ *
+ * The server rolls back the latest accepted player action for the match. In AI
+ * matches, one human undo also consumes any AI responses that happened after
+ * that human action, pauses the AI, then automatically resumes it after the
+ * next successful human mutation.
+ *
+ * In matches with other human seats, a sensitive undo (hidden information was
+ * revealed, or another player acted since) does not apply immediately:
+ * the server records it on `GameState.pendingUndo`, emits `undoRequested`,
+ * and waits for every other human seat to answer with an `undoResponse`.
+ *
+ * @example
+ * ```ts
+ * import { undoMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = undoMessage()
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export declare function undoMessage(): ClientMessage;
+/**
+ * Builds one `undoResponse` socket message.
+ *
+ * Answers the pending undo approval request carried by
+ * `GameState.pendingUndo`. Approving as the last outstanding seat applies the
+ * undo; declining cancels it. A response sent by the original requester
+ * withdraws the request regardless of `approve`.
+ *
+ * @example
+ * ```ts
+ * import { undoResponseMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = undoResponseMessage(true)
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export declare function undoResponseMessage(approve: boolean): ClientMessage;
+/**
+ * Builds one `setAiPaused` socket message.
+ *
+ * Use this for explicit manual control of an attached AI opponent without
+ * changing the underlying game state. Undo-created AI pauses resume
+ * automatically after the next successful human mutation.
+ *
+ * @example
+ * ```ts
+ * import { setAiPausedMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = setAiPausedMessage(true)
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export declare function setAiPausedMessage(paused: boolean): ClientMessage;
+/**
+ * Builds one `syncRequest` socket message.
+ *
+ * @example
+ * ```ts
+ * import { syncRequestMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = syncRequestMessage()
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export declare function syncRequestMessage(): ClientMessage;
+/**
+ * Builds one in-match `chat` socket message.
+ *
+ * The server trims and caps the message before broadcasting it as a
+ * match-history entry.
+ *
+ * @example
+ * ```ts
+ * import { chatMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = chatMessage('ready?')
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export declare function chatMessage(message: string): ClientMessage;
+/**
+ * Builds one transient hand-card interaction cue socket message.
+ *
+ * Cues are live presentation hints only. They do not mutate gameplay state,
+ * history, replay, or saves; the server adds the sender seat before broadcast.
+ *
+ * @example
+ * ```ts
+ * import { interactionCueMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = interactionCueMessage({
+ *   kind: 'handCard',
+ *   index: 0,
+ *   state: 'hover',
+ * })
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export declare function interactionCueMessage(cue: CardInteractionCueRequest): ClientMessage;
+/**
+ * Builds one `ping` socket message.
+ *
+ * The optional nonce is echoed by the server `pong` frame, which lets clients
+ * measure round-trip latency.
+ *
+ * @example
+ * ```ts
+ * import { pingMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = pingMessage('latency-check-1')
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export declare function pingMessage(nonce?: string | null): ClientMessage;
+/**
+ * Wraps one game command into a socket envelope.
+ *
+ * @example
+ * ```ts
+ * import { commandMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = commandMessage('pass')
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export declare function commandMessage(command: GameCommand): ClientMessage;
+/**
+ * Wraps one format-event command into a socket envelope.
+ *
+ * @example
+ * ```ts
+ * import { formatEventMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = formatEventMessage({ type: 'readyNextGame' })
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ */
+export declare function formatEventMessage(command: FormatEventCommand): ClientMessage;
+/**
+ * Wraps one host-authorized AI format-event command into a socket envelope.
+ *
+ * This is only accepted for manual Player vs AI Trilogy ban/pick flows. The
+ * command is applied to the AI seat after the server validates the sender.
+ *
+ * @example
+ * ```ts
+ * import { aiFormatEventMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = aiFormatEventMessage({ type: 'banTrilogyDeck', deckIndex: 1 })
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ */
+export declare function aiFormatEventMessage(command: FormatEventCommand): ClientMessage;

package/dist/messages.js

@@ -0,0 +1,240 @@
+/**
+ * Builds one `ready` socket message.
+ *
+ * Most apps call `matchSession.ready()` instead of constructing envelopes
+ * manually. Use this helper when you are working directly with socket frames.
+ *
+ * @example
+ * ```ts
+ * import { readyMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = readyMessage()
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export function readyMessage() {
+    return { type: 'ready' };
+}
+/**
+ * Builds one `undo` socket message.
+ *
+ * The server rolls back the latest accepted player action for the match. In AI
+ * matches, one human undo also consumes any AI responses that happened after
+ * that human action, pauses the AI, then automatically resumes it after the
+ * next successful human mutation.
+ *
+ * In matches with other human seats, a sensitive undo (hidden information was
+ * revealed, or another player acted since) does not apply immediately:
+ * the server records it on `GameState.pendingUndo`, emits `undoRequested`,
+ * and waits for every other human seat to answer with an `undoResponse`.
+ *
+ * @example
+ * ```ts
+ * import { undoMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = undoMessage()
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export function undoMessage() {
+    return { type: 'undo' };
+}
+/**
+ * Builds one `undoResponse` socket message.
+ *
+ * Answers the pending undo approval request carried by
+ * `GameState.pendingUndo`. Approving as the last outstanding seat applies the
+ * undo; declining cancels it. A response sent by the original requester
+ * withdraws the request regardless of `approve`.
+ *
+ * @example
+ * ```ts
+ * import { undoResponseMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = undoResponseMessage(true)
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export function undoResponseMessage(approve) {
+    return {
+        type: 'undoResponse',
+        payload: { approve },
+    };
+}
+/**
+ * Builds one `setAiPaused` socket message.
+ *
+ * Use this for explicit manual control of an attached AI opponent without
+ * changing the underlying game state. Undo-created AI pauses resume
+ * automatically after the next successful human mutation.
+ *
+ * @example
+ * ```ts
+ * import { setAiPausedMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = setAiPausedMessage(true)
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export function setAiPausedMessage(paused) {
+    return {
+        type: 'setAiPaused',
+        payload: { paused },
+    };
+}
+/**
+ * Builds one `syncRequest` socket message.
+ *
+ * @example
+ * ```ts
+ * import { syncRequestMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = syncRequestMessage()
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export function syncRequestMessage() {
+    return { type: 'syncRequest' };
+}
+/**
+ * Builds one in-match `chat` socket message.
+ *
+ * The server trims and caps the message before broadcasting it as a
+ * match-history entry.
+ *
+ * @example
+ * ```ts
+ * import { chatMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = chatMessage('ready?')
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export function chatMessage(message) {
+    return {
+        type: 'chat',
+        payload: { message },
+    };
+}
+/**
+ * Builds one transient hand-card interaction cue socket message.
+ *
+ * Cues are live presentation hints only. They do not mutate gameplay state,
+ * history, replay, or saves; the server adds the sender seat before broadcast.
+ *
+ * @example
+ * ```ts
+ * import { interactionCueMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = interactionCueMessage({
+ *   kind: 'handCard',
+ *   index: 0,
+ *   state: 'hover',
+ * })
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export function interactionCueMessage(cue) {
+    return {
+        type: 'interactionCue',
+        payload: cue,
+    };
+}
+/**
+ * Builds one `ping` socket message.
+ *
+ * The optional nonce is echoed by the server `pong` frame, which lets clients
+ * measure round-trip latency.
+ *
+ * @example
+ * ```ts
+ * import { pingMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = pingMessage('latency-check-1')
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/websocket
+ */
+export function pingMessage(nonce) {
+    return {
+        type: 'ping',
+        payload: {
+            nonce: nonce ?? null,
+        },
+    };
+}
+/**
+ * Wraps one game command into a socket envelope.
+ *
+ * @example
+ * ```ts
+ * import { commandMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = commandMessage('pass')
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+ */
+export function commandMessage(command) {
+    return {
+        type: 'command',
+        payload: command,
+    };
+}
+/**
+ * Wraps one format-event command into a socket envelope.
+ *
+ * @example
+ * ```ts
+ * import { formatEventMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = formatEventMessage({ type: 'readyNextGame' })
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ */
+export function formatEventMessage(command) {
+    return {
+        type: 'formatEvent',
+        payload: command,
+    };
+}
+/**
+ * Wraps one host-authorized AI format-event command into a socket envelope.
+ *
+ * This is only accepted for manual Player vs AI Trilogy ban/pick flows. The
+ * command is applied to the AI seat after the server validates the sender.
+ *
+ * @example
+ * ```ts
+ * import { aiFormatEventMessage } from '@my-swu/simulator-client'
+ *
+ * const clientMessage = aiFormatEventMessage({ type: 'banTrilogyDeck', deckIndex: 1 })
+ * console.log(clientMessage.type)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ */
+export function aiFormatEventMessage(command) {
+    return {
+        type: 'aiFormatEvent',
+        payload: command,
+    };
+}

package/dist/resources/admin.d.ts

@@ -0,0 +1,63 @@
+import type { SimulatorReportListResponse, SimulatorReportResponse, CardCatalogRefreshResponse, CreateMetaWindowRequest, MatchChatLookupResponse, MetaWindowsResponse, RankedLeaderboardQuery, RankedLeaderboardResponse, RankedProfileRequest, RankedProfileResponse, SetRankedAdmissionRequest, SetSimulatorMaintenanceRequest, SimulatorAdminStatusResponse } from '../generated/index.js';
+import type { SimulatorRequestOptions } from '../http/options.js';
+import type { EngineHttpRequester } from '../http/request.js';
+/**
+ * Optional filters and pagination controls for a ranked leaderboard request.
+ */
+export type RankedLeaderboardOptions = RankedLeaderboardQuery;
+/** Cursor pagination controls for simulator diagnostic reports. */
+export interface SimulatorReportListOptions {
+    cursor?: string;
+    limit?: number;
+}
+/**
+ * Bearer-token credentials for simulator admin calls.
+ */
+export interface SimulatorAdminAuth {
+    /**
+     * Admin token configured on the simulator engine.
+     */
+    token: string;
+}
+/**
+ * Simulator administration API methods.
+ */
+export interface AdminResource {
+    /** Lists safe metadata for retained simulator diagnostic reports. */
+    listSimulatorReports(auth: SimulatorAdminAuth, query?: SimulatorReportListOptions, options?: SimulatorRequestOptions): Promise<SimulatorReportListResponse>;
+    /** Returns one full sanitized simulator support bundle. */
+    getSimulatorReport(auth: SimulatorAdminAuth, reportId: string, options?: SimulatorRequestOptions): Promise<SimulatorReportResponse>;
+    /** Refreshes expansion legality metadata across simulator replicas. */
+    refreshCardCatalog(auth: SimulatorAdminAuth, options?: SimulatorRequestOptions): Promise<CardCatalogRefreshResponse>;
+    /**
+     * Returns live simulator operational status and counters.
+     */
+    status(auth: SimulatorAdminAuth, options?: SimulatorRequestOptions): Promise<SimulatorAdminStatusResponse>;
+    /**
+     * Enables or disables simulator maintenance/drain mode.
+     */
+    setMaintenance(auth: SimulatorAdminAuth, request: SetSimulatorMaintenanceRequest, options?: SimulatorRequestOptions): Promise<SimulatorAdminStatusResponse>;
+    /** Enables or pauses new ranked matchmaking admissions without hiding ranked reads. */
+    setRankedAdmission(auth: SimulatorAdminAuth, request: SetRankedAdmissionRequest, options?: SimulatorRequestOptions): Promise<SimulatorAdminStatusResponse>;
+    /** Creates a ranked meta window, closing any previously open window as needed. */
+    createRankedMetaWindow(auth: SimulatorAdminAuth, request: CreateMetaWindowRequest, options?: SimulatorRequestOptions): Promise<MetaWindowsResponse>;
+    /** Closes one ranked meta window and returns the updated window list. */
+    closeRankedMetaWindow(auth: SimulatorAdminAuth, windowId: string, options?: SimulatorRequestOptions): Promise<MetaWindowsResponse>;
+    /** Lists every ranked meta window and identifies the currently active window. */
+    listRankedMetaWindows(auth: SimulatorAdminAuth, options?: SimulatorRequestOptions): Promise<MetaWindowsResponse>;
+    /**
+     * Returns the server's own record of one match chat message.
+     *
+     * Moderation reports carry a reporter-supplied copy of the message; this is
+     * how a caller replaces that copy with what the match actually broadcast.
+     */
+    matchChatMessage(auth: SimulatorAdminAuth, matchId: string, messageId: string, options?: SimulatorRequestOptions): Promise<MatchChatLookupResponse>;
+    /** Returns one account's placement-safe internal ranked profile. */
+    rankedProfile(auth: SimulatorAdminAuth, request: RankedProfileRequest, options?: SimulatorRequestOptions): Promise<RankedProfileResponse>;
+    /** Returns one paginated, placement-complete internal leaderboard page. */
+    rankedLeaderboard(auth: SimulatorAdminAuth, windowId: string, query?: RankedLeaderboardOptions, options?: SimulatorRequestOptions): Promise<RankedLeaderboardResponse>;
+}
+/**
+ * Creates the simulator admin resource client.
+ */
+export declare function createAdminResource(requester: EngineHttpRequester): AdminResource;

package/dist/resources/admin.js

@@ -0,0 +1,75 @@
+import { jsonBody, jsonHeaders } from '../http/json.js';
+/**
+ * Creates the simulator admin resource client.
+ */
+export function createAdminResource(requester) {
+    return {
+        listSimulatorReports: (auth, query, options) => requester.request('simulator-report-list-response', simulatorReportsPath(query ?? {}), { headers: authHeaders(auth) }, options),
+        getSimulatorReport: (auth, reportId, options) => requester.request('simulator-report-response', `/api/admin/reports/${encodeURIComponent(reportId)}`, { headers: authHeaders(auth) }, options),
+        refreshCardCatalog: (auth, options) => requester.request('card-catalog-refresh-response', '/api/admin/card-catalog/refresh', { headers: authHeaders(auth), method: 'POST' }, options),
+        status: (auth, options) => requester.request('simulator-admin-status-response', '/api/admin/status', { headers: authHeaders(auth) }, options),
+        setMaintenance: (auth, request, options) => requester.request('simulator-admin-status-response', '/api/admin/maintenance', {
+            body: jsonBody(requester.validate('set-simulator-maintenance-request', request)),
+            headers: authHeaders(auth, jsonHeaders()),
+            method: 'POST',
+        }, options),
+        setRankedAdmission: (auth, request, options) => requester.request('simulator-admin-status-response', '/api/admin/ranked/admission', {
+            body: jsonBody(requester.validate('set-ranked-admission-request', request)),
+            headers: authHeaders(auth, jsonHeaders()),
+            method: 'POST',
+        }, options),
+        createRankedMetaWindow: (auth, request, options) => requester.request('meta-windows-response', '/api/admin/ranked/meta-windows', {
+            body: jsonBody(requester.validate('create-meta-window-request', request)),
+            headers: authHeaders(auth, jsonHeaders()),
+            method: 'POST',
+        }, options),
+        closeRankedMetaWindow: (auth, windowId, options) => requester.request('meta-windows-response', `/api/admin/ranked/meta-windows/${encodeURIComponent(windowId)}/close`, { headers: authHeaders(auth), method: 'POST' }, options),
+        listRankedMetaWindows: (auth, options) => requester.request('meta-windows-response', '/api/admin/ranked/meta-windows', { headers: authHeaders(auth) }, options),
+        matchChatMessage: (auth, matchId, messageId, options) => requester.request('match-chat-lookup-response', `/api/admin/matches/${encodeURIComponent(matchId)}/chat/${encodeURIComponent(messageId)}`, { headers: authHeaders(auth) }, options),
+        rankedProfile: (auth, request, options) => requester.request('ranked-profile-response', '/api/admin/ranked/profile', {
+            body: jsonBody(requester.validate('ranked-profile-request', request)),
+            headers: authHeaders(auth, jsonHeaders()),
+            method: 'POST',
+        }, options),
+        rankedLeaderboard: (auth, windowId, query, options) => requester.request('ranked-leaderboard-response', leaderboardPath(requester, windowId, query ?? {}), { headers: authHeaders(auth) }, options),
+    };
+}
+/** Builds a report-list path without exposing pagination implementation. */
+function simulatorReportsPath(options) {
+    const parameters = new URLSearchParams();
+    if (options.cursor) {
+        parameters.set('cursor', options.cursor);
+    }
+    if (options.limit != null) {
+        parameters.set('limit', String(options.limit));
+    }
+    const suffix = parameters.size === 0 ? '' : `?${parameters.toString()}`;
+    return `/api/admin/reports${suffix}`;
+}
+/**
+ * Builds a ranked leaderboard path from the optional query parameters.
+ *
+ * The requester carries the client's validation policy, so the parameters are
+ * checked against `ranked-leaderboard-query` only when the client validates.
+ */
+function leaderboardPath(requester, windowId, options) {
+    const query = requester.validate('ranked-leaderboard-query', options);
+    const parameters = new URLSearchParams();
+    if (query.queue != null) {
+        parameters.set('queue', query.queue);
+    }
+    if (query.offset != null) {
+        parameters.set('offset', String(query.offset));
+    }
+    if (query.limit != null) {
+        parameters.set('limit', String(query.limit));
+    }
+    const suffix = parameters.size === 0 ? '' : `?${parameters.toString()}`;
+    return `/api/admin/ranked/meta-windows/${encodeURIComponent(windowId)}/leaderboard${suffix}`;
+}
+function authHeaders(auth, headers = {}) {
+    return {
+        ...headers,
+        authorization: `Bearer ${auth.token}`,
+    };
+}

package/dist/resources/card-deck-json.d.ts

@@ -0,0 +1,11 @@
+import type { SimulatorRequestOptions } from '../http/options.js';
+import type { EngineHttpRequester } from '../http/request.js';
+import type { DeckInput, DeckJson } from './card-types.js';
+/**
+ * Converts one my-swu JSON deck export into simulator deck input.
+ *
+ * Token cards (the Credit or Force token, …) can ride along in deck
+ * exports but are not deck cards — deck and sideboard entries that only
+ * resolve to a token are skipped instead of failing the import.
+ */
+export declare function convertDeckJson(requester: EngineHttpRequester, input: DeckJson | string, options?: SimulatorRequestOptions): Promise<DeckInput>;