@my-swu/simulator-client 0.1.0

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

@@ -0,0 +1,448 @@
+import type { AiStatusPayload, CreateMatchRequest, GameState, JoinMatchRequest, ListActiveAiMatchesRequest, ListActiveAiMatchesResponse, MatchAccessResponse, MatchSpectatorAccessResponse, MatchSavePayload, RematchMatchResponse, RestoreMatchSaveResponse, SpectateMatchRequest, SubmitMatchDeckRequest } from '../generated/index.js';
+import type { FormatEventCommand } from '../generated/types/format-event-request.js';
+import type { SimulatorRequestOptions } from '../http/options.js';
+/**
+ * Access token and private snapshot returned after creating or joining a match.
+ *
+ * Keep `seatToken` private. It authorizes one player seat for socket and format
+ * event calls.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient, type MatchAccess } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ * const premierHostDeck = {
+ *   leader: 46102,
+ *   leaders: [],
+ *   base: 308,
+ *   cards: Array.from({ length: 50 }, () => 45),
+ *   sideboard: [],
+ * }
+ *
+ * const hostAccess: MatchAccess = await simulatorClient.matches.create({
+ *   format: 'premier',
+ *   playerCount: 2,
+ *   hostDeck: premierHostDeck,
+ *   hostName: 'Host',
+ *   hostAuthenticated: false,
+ *   historyIdentities: [],
+ *   aiOpponents: [],
+ * })
+ * console.log(hostAccess.matchId)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ */
+export type MatchAccess = MatchAccessResponse;
+export type MatchSpectatorAccess = MatchSpectatorAccessResponse;
+/**
+ * Public reference to one match.
+ *
+ * Use this shape for routes, lobby sharing, or join flows where no private seat
+ * credential should be exposed.
+ *
+ * @example
+ * ```ts
+ * import type { MatchReference } from '@my-swu/simulator-client'
+ *
+ * const matchReference: MatchReference = { matchId: 'match_123' }
+ * console.log(matchReference.matchId)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ */
+export interface MatchReference {
+    /**
+     * Public match id.
+     */
+    matchId: string;
+}
+/**
+ * Minimal data needed to open one match socket.
+ *
+ * This is the small persisted shape needed for reconnecting one private seat.
+ *
+ * @example
+ * ```ts
+ * import type { MatchAccessInput } from '@my-swu/simulator-client'
+ *
+ * const reconnectAccess: MatchAccessInput = {
+ *   matchId: 'match_123',
+ *   seatToken: 'seat_token_123',
+ * }
+ *
+ * console.log(reconnectAccess.matchId)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/reconnect
+ */
+export interface MatchAccessInput extends MatchReference {
+    /**
+     * Private token authorizing one seat.
+     */
+    seatToken: string;
+    /**
+     * Resolved seed for a private solo-vs-AI match, retained across reconnects.
+     */
+    replaySeed?: number;
+}
+export interface MatchSpectatorAccessInput extends MatchReference {
+    /**
+     * Private token authorizing read-only spectator access.
+     */
+    spectatorToken: string;
+}
+export type MatchConnectionAccessInput = MatchAccessInput | MatchSpectatorAccessInput;
+/**
+ * Match resource API methods.
+ *
+ * Use this resource for HTTP-only match lifecycle calls. For a stateful socket
+ * wrapper, create a `MatchSession` through `client.session`.
+ *
+ * @example
+ * ```ts
+ * import { createSimulatorClient } from '@my-swu/simulator-client'
+ *
+ * const simulatorClient = createSimulatorClient({
+ *   baseUrl: 'http://127.0.0.1:4000',
+ * })
+ *
+ * const premierHostDeck = {
+ *   leader: 46102,
+ *   leaders: [],
+ *   base: 308,
+ *   cards: Array.from({ length: 50 }, () => 45),
+ *   sideboard: [],
+ * }
+ * const hostAccess = await simulatorClient.matches.create({
+ *   format: 'premier',
+ *   playerCount: 2,
+ *   hostDeck: premierHostDeck,
+ *   hostName: 'Host',
+ *   hostAuthenticated: false,
+ *   historyIdentities: [],
+ *   aiOpponents: [],
+ * })
+ *
+ * console.log(hostAccess.matchId)
+ * ```
+ *
+ * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle
+ * @see https://simulator-sdk.my-swu.com/guide/match-session
+ */
+export interface MatchesResource {
+    /** Records an intentional player departure without conceding the match. */
+    leave(access: MatchAccessInput, options?: SimulatorRequestOptions): Promise<void>;
+    /**
+     * Permanently abandons a host-owned solo AI match.
+     *
+     * Started matches record a host concession before the server removes the
+     * runtime. Ordinary socket disconnects remain resumable and do not call this
+     * endpoint.
+     */
+    abandon(access: MatchAccessInput, options?: SimulatorRequestOptions): Promise<void>;
+    /** Lists caller-owned resumable AI matches retaining a blocked quota slot. */
+    listActiveAi(request: ListActiveAiMatchesRequest, options?: SimulatorRequestOptions): Promise<ListActiveAiMatchesResponse>;
+    /**
+     * Applies one out-of-game format command such as sideboarding or Trilogy selection.
+     *
+     * @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 nextGameSnapshot = await simulatorClient.matches.applyFormatEvent(
+     *   hostAccess,
+     *   { type: 'readyNextGame', ready: true },
+     * )
+     *
+     * console.log(nextGameSnapshot.phase)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay#out-of-game-commands
+     */
+    applyFormatEvent(access: MatchAccessInput, command: FormatEventCommand, options?: SimulatorRequestOptions): Promise<GameState>;
+    /**
+     * Creates one match and returns host access.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     * })
+     * const premierHostDeck = {
+     *   leader: 46102,
+     *   leaders: [],
+     *   base: 308,
+     *   cards: Array.from({ length: 50 }, () => 45),
+     *   sideboard: [],
+     * }
+     *
+     * const hostAccess = await simulatorClient.matches.create({
+     *   format: 'premier',
+     *   playerCount: 2,
+     *   hostDeck: premierHostDeck,
+     *   hostName: 'Host',
+     *   hostAuthenticated: false,
+     *   historyIdentities: [],
+     *   aiOpponents: [],
+     * })
+     *
+     * console.log(hostAccess.seat)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle#create
+     */
+    create(request: CreateMatchRequest, options?: SimulatorRequestOptions): Promise<MatchAccess>;
+    /**
+     * Fetches the public match projection.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     * })
+     *
+     * const publicMatchSnapshot = await simulatorClient.matches.get('match_123')
+     * console.log(publicMatchSnapshot.phase)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/http-client
+     */
+    get(match: string | MatchReference, options?: SimulatorRequestOptions): Promise<GameState>;
+    /**
+     * Joins an existing match as the next open seat.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     * })
+     * const premierGuestDeck = {
+     *   leader: 46107,
+     *   leaders: [],
+     *   base: 309,
+     *   cards: Array.from({ length: 50 }, () => 35),
+     *   sideboard: [],
+     * }
+     *
+     * const guestAccess = await simulatorClient.matches.join(
+     *   { matchId: 'match_123' },
+     *   {
+     *     deck: premierGuestDeck,
+     *     name: 'Guest',
+     *     authenticated: false,
+     *     historyIdentities: [],
+     *   },
+     * )
+     *
+     * console.log(guestAccess.seat)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle#join
+     */
+    join(match: MatchReference, request: JoinMatchRequest, options?: SimulatorRequestOptions): Promise<MatchAccess>;
+    /**
+     * Joins an existing match as a read-only spectator.
+     */
+    spectate(match: MatchReference, request: SpectateMatchRequest, options?: SimulatorRequestOptions): Promise<MatchSpectatorAccess>;
+    /**
+     * Submits (or replaces) the deck of a joined seat while the match is
+     * still gathering players.
+     *
+     * Pairs with a deck-less `join` (omit `deck` in the join request) — the
+     * seat reserves its slot first and registers the deck here. The seat
+     * cannot mark itself ready until a deck has been submitted, and the
+     * deck locks in once the seat is ready.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient } from '@my-swu/simulator-client'
+     *
+     * const simulatorClient = createSimulatorClient({
+     *   baseUrl: 'http://127.0.0.1:4000',
+     * })
+     *
+     * const guestAccess = await simulatorClient.matches.join({ matchId: 'match_123' }, {
+     *   name: 'Guest',
+     *   authenticated: false,
+     *   historyIdentities: [],
+     * })
+     * const premierGuestDeck = {
+     *   leader: 46107,
+     *   leaders: [],
+     *   base: 309,
+     *   cards: Array.from({ length: 50 }, () => 35),
+     *   sideboard: [],
+     * }
+     *
+     * const guestMatchSnapshot = await simulatorClient.matches.submitDeck(guestAccess, {
+     *   deck: premierGuestDeck,
+     * })
+     * console.log(guestMatchSnapshot.players[1]?.deckSubmitted)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/match-lifecycle#join
+     */
+    submitDeck(access: MatchAccessInput, request: Omit<SubmitMatchDeckRequest, 'seatToken'>, options?: SimulatorRequestOptions): Promise<GameState>;
+    /**
+     * Rolls back the latest accepted player action for one match.
+     *
+     * The returned snapshot is the authoritative private view for the supplied
+     * seat after rollback.
+     *
+     * @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 restoredMatchSnapshot = await simulatorClient.matches.undo(hostAccess)
+     * console.log(restoredMatchSnapshot.phase)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+     */
+    undo(access: MatchAccessInput, options?: SimulatorRequestOptions): Promise<GameState>;
+    /**
+     * Answers the pending undo approval request for one match.
+     *
+     * 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 { 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 undoMatchSnapshot = await simulatorClient.matches.respondUndo(hostAccess, true)
+     * console.log(undoMatchSnapshot.pendingUndo)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+     */
+    respondUndo(access: MatchAccessInput, approve: boolean, options?: SimulatorRequestOptions): Promise<GameState>;
+    /**
+     * Offers, accepts, or declines a rematch against the same opponent.
+     *
+     * Both seats call this. The first one gets `status: 'waiting'`; once every
+     * seat has asked, `series.rematchReady` flips on the match snapshot and each
+     * seat calls again to claim its own `status: 'ready'` access to the new
+     * match. Repeat claims return the same access, so a reconnecting client can
+     * safely ask again. Passing `accept: false` declines, and withdraws this
+     * seat's own offer.
+     *
+     * @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 rematch = await simulatorClient.matches.rematch(hostAccess, true)
+     * if (rematch.status === 'ready') {
+     *   console.log(rematch.access.matchId)
+     * }
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+     */
+    rematch(access: MatchAccessInput, accept: boolean, options?: SimulatorRequestOptions): Promise<RematchMatchResponse>;
+    /**
+     * Pauses or resumes an attached AI opponent for one match.
+     *
+     * The response reports each AI-controlled seat and its pause state. Non-AI
+     * matches accept the request and return an empty `seats` list.
+     *
+     * @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 status = await simulatorClient.matches.setAiPaused(hostAccess, true)
+     * console.log(status.seats.every(seat => seat.paused))
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/driving-gameplay
+     */
+    setAiPaused(access: MatchAccessInput, paused: boolean, options?: SimulatorRequestOptions): Promise<AiStatusPayload>;
+    /**
+     * Captures a full state snapshot of an authorized, finished match.
+     *
+     * The returned object contains the engine's `MatchState` plus the
+     * per-seat decks needed to rebuild the catalog at restore time. SDK
+     * consumers persist it however they like — clipboard, file download,
+     * IndexedDB, server upload — the simulator does not store it.
+     *
+     * Unlike the older debug replay snapshot, this works for AI-opponent
+     * matches and does not need to replay any commands at restore time.
+     *
+     * @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 save = await simulatorClient.matches.save(hostAccess)
+     * localStorage.setItem('swu-save', JSON.stringify(save))
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/save-restore
+     */
+    save(access: MatchAccessInput, options?: SimulatorRequestOptions): Promise<MatchSavePayload>;
+    /**
+     * Restores a previously saved match into a fresh live session.
+     *
+     * Returns the new match id and per-seat access tokens — the original
+     * tokens are not preserved, so SDK consumers should treat the returned
+     * session as freshly created.
+     *
+     * @example
+     * ```ts
+     * import { createSimulatorClient, type MatchSavePayload } 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 persisted = JSON.parse(localStorage.getItem('swu-save') ?? '{}') as MatchSavePayload
+     * const restored = await simulatorClient.matches.restore(hostAccess, persisted)
+     * console.log(restored.matchId, restored.accesses.length)
+     * ```
+     *
+     * @see https://simulator-sdk.my-swu.com/guide/save-restore
+     */
+    restore(source: MatchAccessInput, save: MatchSavePayload, options?: SimulatorRequestOptions): Promise<RestoreMatchSaveResponse>;
+}

package/dist/resources/match-types.js

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

package/dist/resources/matches.d.ts

@@ -0,0 +1,16 @@
+import type { EngineHttpRequester } from '../http/request.js';
+import type { MatchesResource } from './match-types.js';
+export type * from './match-types.js';
+/**
+ * Dependencies needed by the match resource.
+ */
+export interface MatchesResourceOptions {
+    /**
+     * HTTP requester shared with other resources.
+     */
+    requester: EngineHttpRequester;
+}
+/**
+ * Creates the match resource client.
+ */
+export declare function createMatchesResource(options: MatchesResourceOptions): MatchesResource;

package/dist/resources/matches.js

@@ -0,0 +1,109 @@
+import { jsonBody, jsonHeaders } from '../http/json.js';
+/**
+ * Creates the match resource client.
+ */
+export function createMatchesResource(options) {
+    const { requester } = options;
+    return {
+        leave: (access, options) => requester.request('leave-match-response', `/api/matches/${matchIdFrom(access)}/leave`, {
+            body: jsonBody(requester.validate('leave-match-request', { seatToken: access.seatToken })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options).then(() => undefined),
+        abandon: (access, options) => requester.request('abandon-match-response', `/api/matches/${matchIdFrom(access)}/abandon`, {
+            body: jsonBody(requester.validate('abandon-match-request', {
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options).then(() => undefined),
+        listActiveAi: (request, options) => requester.request('list-active-ai-matches-response', '/api/matches/active-ai', {
+            body: jsonBody(requester.validate('list-active-ai-matches-request', request)),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        applyFormatEvent: (access, command, options) => requester.request('format-event-response', `/api/matches/${matchIdFrom(access)}/format-events`, {
+            body: jsonBody(requester.validate('format-event-request', {
+                command,
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options).then(response => response.snapshot),
+        create: (request, options) => requester.request('match-access-response', '/api/matches', {
+            body: jsonBody(requester.validate('create-match-request', request)),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        get: (match, options) => requester.request('get-match-response', `/api/matches/${matchIdFrom(match)}`, {}, options)
+            .then(response => response.snapshot),
+        join: (match, request, options) => requester.request('match-access-response', `/api/matches/${matchIdFrom(match)}/join`, {
+            body: jsonBody(requester.validate('join-match-request', request)),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        spectate: (match, request, options) => requester.request('match-spectator-access-response', `/api/matches/${matchIdFrom(match)}/spectate`, {
+            body: jsonBody(requester.validate('spectate-match-request', request)),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        submitDeck: (access, request, options) => requester.request('submit-match-deck-response', `/api/matches/${matchIdFrom(access)}/deck`, {
+            body: jsonBody(requester.validate('submit-match-deck-request', {
+                ...request,
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options).then(response => response.snapshot),
+        undo: (access, options) => requester.request('undo-match-response', `/api/matches/${matchIdFrom(access)}/undo`, {
+            body: jsonBody(requester.validate('undo-match-request', {
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options).then(response => response.snapshot),
+        respondUndo: (access, approve, options) => requester.request('undo-match-response', `/api/matches/${matchIdFrom(access)}/undo/respond`, {
+            body: jsonBody(requester.validate('undo-respond-match-request', {
+                approve,
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options).then(response => response.snapshot),
+        rematch: (access, accept, options) => requester.request('rematch-match-response', `/api/matches/${matchIdFrom(access)}/rematch`, {
+            body: jsonBody(requester.validate('rematch-match-request', {
+                accept,
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        setAiPaused: (access, paused, options) => requester.request('set-ai-paused-response', `/api/matches/${matchIdFrom(access)}/ai/pause`, {
+            body: jsonBody(requester.validate('set-ai-paused-request', {
+                paused,
+                seatToken: access.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        save: (access, options) => requester.request('match-save-payload', `/api/matches/${matchIdFrom(access)}/save`, {
+            body: jsonBody(requester.validate('save-match-request', { seatToken: access.seatToken })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+        restore: (source, save, options) => requester.request('restore-match-save-response', '/api/matches/restore', {
+            body: jsonBody(requester.validate('restore-match-save-request', {
+                save,
+                seatToken: source.seatToken,
+            })),
+            headers: jsonHeaders(),
+            method: 'POST',
+        }, options),
+    };
+}
+/**
+ * Reads a match id from either a public id string or match reference object.
+ */
+function matchIdFrom(match) {
+    return typeof match === 'string' ? match : match.matchId;
+}

package/dist/resources/ranked.d.ts

@@ -0,0 +1,24 @@
+import type { MetaWindowsResponse, RankedLeaderboardQuery, RankedLeaderboardResponse, RankedMatchmakingRequest, RankedProfileRequest, RankedProfileResponse } from '../generated/index.js';
+import type { EngineHttpRequester } from '../http/request.js';
+import type { LobbyAccessResponse } from './lobby-types.js';
+/**
+ * Optional filters and pagination controls for a ranked leaderboard request.
+ */
+export type RankedLeaderboardOptions = RankedLeaderboardQuery;
+/**
+ * Ranked matchmaking, profile, and leaderboard APIs.
+ */
+export interface RankedResource {
+    /** Returns every ranked meta window and identifies the currently active window. */
+    metaWindows(): Promise<MetaWindowsResponse>;
+    /** Returns the authenticated account's placement-safe profile for one meta window. */
+    profile(request: RankedProfileRequest): Promise<RankedProfileResponse>;
+    /** Returns one paginated, placement-complete leaderboard for a meta window. */
+    leaderboard(windowId: string, options?: RankedLeaderboardOptions): Promise<RankedLeaderboardResponse>;
+    /** Enters the verified account into a ranked matchmaking queue. */
+    matchmakeRanked(request: RankedMatchmakingRequest): Promise<LobbyAccessResponse>;
+}
+/**
+ * Creates the ranked API resource.
+ */
+export declare function createRankedResource(requester: EngineHttpRequester): RankedResource;

package/dist/resources/ranked.js

@@ -0,0 +1,47 @@
+import { jsonBody, jsonHeaders } from '../http/json.js';
+import { parseSchema } from '../validators.js';
+/**
+ * Creates the ranked API resource.
+ */
+export function createRankedResource(requester) {
+    return {
+        metaWindows: () => requester.request('meta-windows-response', '/api/ranked/meta-windows'),
+        profile: request => requester.request('ranked-profile-response', '/api/ranked/profile', jsonPost('ranked-profile-request', request)),
+        leaderboard: (windowId, options) => requester.request('ranked-leaderboard-response', leaderboardPath(windowId, options ?? {})),
+        matchmakeRanked: request => requestResource(requester, 'lobby-access-response', '/api/lobbies/matchmaking/ranked', jsonPost('ranked-matchmaking-request', request)),
+    };
+}
+/**
+ * Builds a ranked leaderboard path from validated optional query parameters.
+ */
+function leaderboardPath(windowId, options) {
+    const query = parseSchema('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/ranked/meta-windows/${encodeURIComponent(windowId)}/leaderboard${suffix}`;
+}
+/**
+ * Builds a JSON POST request after validating the body against an SDK schema.
+ */
+function jsonPost(schemaName, body) {
+    return {
+        body: jsonBody(parseSchema(schemaName, body)),
+        headers: jsonHeaders(),
+        method: 'POST',
+    };
+}
+/**
+ * Validates a response with a generated schema before returning a curated DTO type.
+ */
+function requestResource(requester, schemaName, pathname, init) {
+    return requester.request(schemaName, pathname, init);
+}