vairified 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/errors.ts
 var VairifiedError = class extends Error {
-  /** HTTP status code */
+  /** HTTP status code (if the error came from an API response). */
   statusCode;
-  /** Response body */
+  /** Raw response body parsed as JSON when available. */
   response;
   constructor(message, statusCode, response) {
     super(message);
@@ -12,7 +12,7 @@ var VairifiedError = class extends Error {
   }
 };
 var RateLimitError = class extends VairifiedError {
-  /** Seconds to wait before retrying */
+  /** Seconds to wait before retrying, or `undefined` if the server didn't say. */
   retryAfter;
   constructor(message = "Rate limit exceeded", retryAfter, response) {
     super(message, 429, response);
@@ -39,7 +39,10 @@ var ValidationError = class extends VairifiedError {
   }
 };
 var OAuthError = class extends VairifiedError {
-  /** OAuth error code (e.g., 'invalid_grant', 'expired_token') */
+  /**
+   * OAuth error code such as `'invalid_grant'`, `'invalid_scope'`,
+   * or `'expired_token'`. Check this to branch on the specific failure.
+   */
   errorCode;
   constructor(message = "OAuth error", errorCode, response) {
     super(message, void 0, response);
@@ -48,943 +51,1082 @@ var OAuthError = class extends VairifiedError {
   }
 };
 
-// src/models.ts
-var RatingSplit = class {
-  /** The rating value */
-  rating;
-  /** Abbreviation (e.g., "VG", "50+") */
-  abbr;
-  /** Date of last match in this category */
-  datePlayed;
-  constructor(data) {
-    if (typeof data === "number") {
-      this.rating = data;
-      this.abbr = "";
-    } else {
-      const ratingVal = data.rating;
-      this.rating = typeof ratingVal === "string" ? Number.parseFloat(ratingVal) || 0 : ratingVal;
-      this.abbr = data.abbr;
-      this.datePlayed = data.date_played;
+// src/http.ts
+var HttpTransport = class {
+  #config;
+  constructor(config) {
+    this.#config = config;
+  }
+  async request(options) {
+    const url = buildUrl(this.#config.baseUrl, options.path, options.query);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(new Error(`Request timed out after ${this.#config.timeoutMs}ms`)),
+      this.#config.timeoutMs
+    );
+    const headers = {
+      "X-API-Key": this.#config.apiKey,
+      Accept: "application/json"
+    };
+    const init = {
+      method: options.method,
+      headers,
+      signal: controller.signal
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(options.body);
     }
-  }
-};
-var RatingSplits = class {
-  /** Map of category names to rating splits */
-  splits;
-  constructor(data) {
-    this.splits = /* @__PURE__ */ new Map();
-    if (data) {
-      for (const [key, value] of Object.entries(data)) {
-        this.splits.set(key, new RatingSplit(value));
-      }
+    let response;
+    try {
+      response = await this.#config.fetch(url, init);
+    } finally {
+      clearTimeout(timeoutId);
     }
-  }
-  /** Get rating for a category */
-  get(category) {
-    return this.splits.get(category)?.rating;
-  }
-  /** Open division rating */
-  get open() {
-    return this.get("open") ?? this.get("VO");
-  }
-  /** Gender-specific rating (same gender doubles) */
-  get gender() {
-    return this.get("gender") ?? this.get("VG");
-  }
-  /** Mixed doubles rating */
-  get mixed() {
-    return this.get("mixed") ?? this.get("VM");
-  }
-  /** Recreational rating */
-  get recreational() {
-    return this.get("recreational") ?? this.get("R");
-  }
-  /** Singles rating */
-  get singles() {
-    return this.get("singles") ?? this.get("S");
-  }
-  /** Best available verified rating */
-  get best() {
-    const ratings = Array.from(this.splits.values()).map((s) => s.rating).filter((r) => r > 0);
-    return ratings.length > 0 ? Math.max(...ratings) : void 0;
-  }
-  /** Convert to plain object */
-  toJSON() {
-    const result = {};
-    for (const [key, split] of this.splits) {
-      result[key] = { rating: split.rating, abbr: split.abbr };
+    if (!response.ok) {
+      await throwFromResponse(response);
     }
-    return result;
-  }
-};
-function isSearchData(data) {
-  return "displayName" in data;
-}
-var Player = class {
-  /** External player ID (vair_mem_xxx format) */
-  id;
-  /** Display name (First Name + Last Initial from search) */
-  displayName;
-  /** First name (only from connected member) */
-  firstName;
-  /** Last name (only from connected member) */
-  lastName;
-  /** Primary/overall rating (2.0-8.0) */
-  rating;
-  /** Whether player is verified */
-  isVairified;
-  /** Whether player has connected to your app */
-  isConnected;
-  /** Ratings by category (only from connected member) */
-  ratingSplits;
-  /** City */
-  city;
-  /** State code */
-  state;
-  /** Country code */
-  country;
-  _client;
-  constructor(data, client) {
-    if (isSearchData(data)) {
-      this.id = data.id;
-      this.displayName = data.displayName;
-      this.rating = data.rating ?? 0;
-      this.isVairified = data.isVairified ?? false;
-      this.isConnected = data.isConnected ?? false;
-      this.ratingSplits = new RatingSplits();
-    } else {
-      this.id = data.id;
-      this.firstName = data.firstName ?? "";
-      this.lastName = data.lastName ?? "";
-      this.rating = data.rating ?? 0;
-      this.isVairified = data.isVairified ?? false;
-      this.isConnected = true;
-      this.ratingSplits = new RatingSplits(data.ratingSplits);
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      return void 0;
     }
-    this.city = data.city;
-    this.state = data.state;
-    this.country = data.country;
-    this._client = client;
-  }
-  /** Full name (or display name if full name not available) */
-  get name() {
-    if (this.firstName && this.lastName) {
-      return `${this.firstName} ${this.lastName}`.trim();
+    const text = await response.text();
+    if (text.length === 0) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new VairifiedError(`Unable to parse response as JSON: ${text}`, response.status);
     }
-    return this.displayName ?? "";
-  }
-  /** Best verified rating */
-  get verifiedRating() {
-    return this.ratingSplits.best;
-  }
-  toString() {
-    const verified = this.isVairified ? " \u2713" : "";
-    return `${this.name} (${this.rating.toFixed(2)})${verified}`;
   }
 };
-var Member = class extends Player {
-  /** Email address (only if profile:email scope granted) */
-  email;
-  /** Scopes the player granted to your app */
-  grantedScopes;
-  constructor(data, client) {
-    super(data, client);
-    this.email = data.email;
-    this.grantedScopes = data.grantedScopes ?? [];
-  }
-  /** Check if the player has granted a specific scope */
-  hasScope(scope) {
-    return this.grantedScopes.includes(scope);
-  }
-  /** Refresh member data from API */
-  async refresh() {
-    if (!this._client) {
-      throw new Error("Member not connected to client");
+function buildUrl(baseUrl, path, query) {
+  const cleanBase = baseUrl.replace(/\/+$/, "");
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(cleanBase + cleanPath);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === null || value === void 0) continue;
+      if (Array.isArray(value)) {
+        if (value.length === 0) continue;
+        url.searchParams.set(key, value.join(","));
+      } else {
+        url.searchParams.set(key, String(value));
+      }
     }
-    const updated = await this._client.getMember(this.id);
-    Object.assign(this, updated);
-    return this;
   }
-};
-function generateId() {
-  return `SDK-${Math.random().toString(36).substring(2, 14)}`;
+  return url.toString();
 }
-var Match = class {
-  /** Event/tournament name */
-  event;
-  /** Bracket/division name */
-  bracket;
-  /** Match date */
-  date;
-  /** Team 1 player IDs */
-  team1;
-  /** Team 2 player IDs */
-  team2;
-  /** Game scores */
-  scores;
-  /** Match type */
-  matchType;
-  /** Match source */
-  source;
-  /** Location */
-  location;
-  /** Unique identifier */
-  identifier;
-  /** Match ID (set after submission) */
-  id;
-  constructor(data) {
-    this.event = data.event;
-    this.bracket = data.bracket;
-    this.date = data.date instanceof Date ? data.date : new Date(data.date);
-    this.team1 = data.team1;
-    this.team2 = data.team2;
-    this.scores = data.scores;
-    this.matchType = data.matchType ?? "SIDEOUT";
-    this.source = data.source ?? "PARTNER";
-    this.location = data.location;
-    this.identifier = data.identifier ?? generateId();
-  }
-  /** Match format: SINGLES or DOUBLES */
-  get format() {
-    return this.team1.length === 1 ? "SINGLES" : "DOUBLES";
-  }
-  /** Team that won (1 or 2). Returns 0 if tie. */
-  get winner() {
-    let t1Wins = 0;
-    let t2Wins = 0;
-    for (const [s1, s2] of this.scores) {
-      if (s1 > s2) t1Wins++;
-      else if (s2 > s1) t2Wins++;
-    }
-    if (t1Wins > t2Wins) return 1;
-    if (t2Wins > t1Wins) return 2;
-    return 0;
-  }
-  /** Score summary like "11-9, 11-7" */
-  get scoreSummary() {
-    return this.scores.map(([s1, s2]) => `${s1}-${s2}`).join(", ");
-  }
-  /** Convert to API request format */
-  toJSON() {
-    const player1A = this.team1[0];
-    const player1B = this.team2[0];
-    if (!player1A || !player1B) {
-      throw new Error("Match must have at least one player per team");
+async function throwFromResponse(response) {
+  const status = response.status;
+  const text = await response.text().catch(() => "");
+  let body = null;
+  if (text.length > 0) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = null;
     }
-    const teamA = { player1: player1A };
-    const teamB = { player1: player1B };
-    if (this.team1[1]) teamA.player2 = this.team1[1];
-    if (this.team2[1]) teamB.player2 = this.team2[1];
-    const gameKeys = ["game1", "game2", "game3", "game4", "game5"];
-    for (let i = 0; i < Math.min(this.scores.length, 5); i++) {
-      const score = this.scores[i];
-      const key = gameKeys[i];
-      if (score && key) {
-        teamA[key] = score[0];
-        teamB[key] = score[1];
-      }
+  }
+  let message;
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    const apiBody = body;
+    message = apiBody.message || apiBody.error || text || `HTTP ${status}`;
+  } else {
+    message = text || `HTTP ${status}`;
+  }
+  switch (status) {
+    case 400:
+      throw new ValidationError(message, body);
+    case 401:
+      throw new AuthenticationError(message, body);
+    case 404:
+      throw new NotFoundError(message, body);
+    case 429: {
+      const retryAfterHeader = response.headers.get("Retry-After");
+      const retryAfter = retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : void 0;
+      throw new RateLimitError(message, Number.isFinite(retryAfter) ? retryAfter : void 0, body);
     }
-    return {
-      identifier: this.identifier,
-      bracket: this.bracket,
-      event: this.event,
-      format: this.format,
-      matchDate: this.date.toISOString(),
-      matchSource: this.source,
-      matchType: this.matchType,
-      location: this.location,
-      teamA,
-      teamB
+    default:
+      throw new VairifiedError(message, status, body);
+  }
+}
+
+// src/resources/leaderboard.ts
+var LeaderboardResource = class {
+  #http;
+  /** @internal */
+  constructor(http) {
+    this.#http = http;
+  }
+  /** Fetch a leaderboard page with optional filters. */
+  async list(options = {}) {
+    const query = {
+      limit: options.limit ?? 50,
+      offset: options.offset ?? 0,
+      category: options.category,
+      ageBracket: options.ageBracket,
+      scope: options.scope,
+      state: options.state,
+      city: options.city,
+      clubId: options.clubId,
+      gender: options.gender?.toUpperCase(),
+      minGames: options.minGames,
+      search: options.search,
+      verifiedOnly: options.verifiedOnly === true ? true : void 0
+    };
+    const data = await this.#http.request({
+      method: "GET",
+      path: "/leaderboard",
+      query
+    });
+    return data ?? {};
+  }
+  /** Fetch a specific player's rank plus nearby players. */
+  async rank(playerId, options = {}) {
+    const body = {
+      playerId,
+      category: options.category ?? "doubles",
+      ageBracket: options.ageBracket ?? "open",
+      scope: options.scope ?? "global",
+      contextSize: options.contextSize ?? 5
     };
+    if (options.state !== void 0) body.state = options.state;
+    if (options.city !== void 0) body.city = options.city;
+    if (options.clubId !== void 0) body.clubId = options.clubId;
+    const data = await this.#http.request({
+      method: "POST",
+      path: "/leaderboard/rank",
+      body
+    });
+    return data ?? {};
+  }
+  /** List available leaderboard categories, brackets, and scopes. */
+  async categories() {
+    const data = await this.#http.request({
+      method: "GET",
+      path: "/leaderboard/categories"
+    });
+    return data ?? {};
   }
 };
-var MatchResult = class {
-  /** Whether submission succeeded */
+
+// src/models/match-batch-result.ts
+var MatchBatchResult = class {
   success;
-  /** Number of matches processed */
   numMatches;
-  /** Number of games recorded */
   numGames;
-  /** Whether this was a dry-run (validation only) */
   dryRun;
-  /** Human-readable result message */
   message;
-  /** List of validation/processing errors */
   errors;
-  constructor(data) {
-    this.success = data.success;
-    this.numMatches = data.numMatches;
-    this.numGames = data.numGames;
-    this.dryRun = data.dryRun ?? false;
-    this.message = data.message;
-    this.errors = data.errors ?? [];
-  }
-  /** Alias for dryRun */
+  constructor(wire) {
+    this.success = wire.success;
+    this.numMatches = wire.numMatches;
+    this.numGames = wire.numGames;
+    this.dryRun = wire.dryRun ?? null;
+    this.message = wire.message ?? null;
+    this.errors = wire.errors ? Object.freeze([...wire.errors]) : null;
+    Object.freeze(this);
+  }
+  /** Shorthand: successful submission with zero errors. */
+  get ok() {
+    return this.success && (this.errors === null || this.errors.length === 0);
+  }
+  /** Whether this was a dry-run (validation only, nothing persisted). */
   get isDryRun() {
-    return this.dryRun;
+    return this.dryRun === true;
   }
-  /** Returns true if submission succeeded without errors */
+  toString() {
+    const mode = this.isDryRun ? " [dry-run]" : "";
+    const errs = this.errors && this.errors.length > 0 ? ` errors=${this.errors.length}` : "";
+    const status = this.ok ? "ok" : "FAILED";
+    return `MatchBatchResult ${status}${mode} matches=${this.numMatches} games=${this.numGames}${errs}`;
+  }
+};
+
+// src/models/tournament-import-result.ts
+var TournamentImportResult = class {
+  success;
+  matchesImported;
+  gamesRecorded;
+  ghostPlayersCreated;
+  existingPlayersMatched;
+  dryRun;
+  message;
+  errors;
+  /** @internal */
+  constructor(wire) {
+    this.success = wire.success;
+    this.matchesImported = wire.matchesImported;
+    this.gamesRecorded = wire.gamesRecorded;
+    this.ghostPlayersCreated = wire.ghostPlayersCreated;
+    this.existingPlayersMatched = wire.existingPlayersMatched;
+    this.dryRun = wire.dryRun ?? false;
+    this.message = wire.message;
+    this.errors = Object.freeze(wire.errors ?? []);
+    Object.freeze(this);
+  }
+  /** True when the import succeeded without errors. */
   get ok() {
     return this.success && this.errors.length === 0;
   }
 };
-var RatingUpdate = class {
-  /** External player ID (vair_mem_xxx format) */
-  id;
-  /** Member name */
-  memberName;
-  /** Previous rating */
-  previousRating;
-  /** New rating */
-  newRating;
-  /** When the change occurred */
-  changedAt;
-  /** Updated rating splits */
-  ratingSplits;
-  _client;
-  constructor(data, client) {
-    this.id = data.id;
-    this.memberName = data.memberName;
-    this.previousRating = data.previousRating ?? 0;
-    this.newRating = data.newRating ?? 0;
-    this.changedAt = data.changedAt ? new Date(data.changedAt) : /* @__PURE__ */ new Date();
-    this.ratingSplits = new RatingSplits(data.ratingSplits);
-    this._client = client;
-  }
-  /** Amount of rating change */
-  get change() {
-    return this.newRating - this.previousRating;
+
+// src/resources/matches.ts
+var MatchesResource = class {
+  #http;
+  /** @internal */
+  constructor(http) {
+    this.#http = http;
   }
-  /** Whether rating improved */
-  get improved() {
-    return this.change > 0;
+  /**
+   * Submit a {@link MatchBatch} for rating calculation.
+   *
+   * All players in every match must have granted the `user:match:submit`
+   * scope via OAuth (unless your API key has the
+   * `user:match:submit:trusted` scope, which skips per-player consent).
+   *
+   * Set `batch.dryRun = true` to validate without persisting.
+   *
+   * ```ts
+   * const result = await client.matches.submit({
+   *   sport: 'pickleball',
+   *   winScore: 11,
+   *   winBy: 2,
+   *   bracket: '4.0 Doubles',
+   *   event: 'Weekly League',
+   *   matchDate: '2026-04-11T14:00:00Z',
+   *   matches: [
+   *     {
+   *       identifier: 'm1',
+   *       teams: [['vair_mem_aaa', 'vair_mem_bbb'],
+   *               ['vair_mem_ccc', 'vair_mem_ddd']],
+   *       games: [{ scores: [11, 8] }, { scores: [11, 5] }],
+   *     },
+   *   ],
+   * });
+   * if (result.ok) {
+   *   console.log(`Submitted ${result.numGames} games`);
+   * }
+   * ```
+   */
+  async submit(batch) {
+    const wire = await this.#http.request({
+      method: "POST",
+      path: "/partner/matches",
+      body: batch
+    });
+    return new MatchBatchResult(wire);
   }
-  /** Fetch the member associated with this update */
-  async getMember() {
-    if (!this._client) {
-      throw new Error("Update not connected to client");
-    }
-    return this._client.getMember(this.id);
+  /**
+   * Import tournament results.
+   *
+   * The request body is a free-form JSON object whose structure is
+   * defined by the Vairified tournament import schema. Set
+   * `body.dryRun = true` to validate without persisting.
+   *
+   * @param body - Tournament import payload.
+   * @returns {@link TournamentImportResult} with match/game counts.
+   * @category Matches
+   *
+   * @example
+   * ```ts
+   * const result = await client.matches.tournamentImport({
+   *   sport: 'pickleball',
+   *   tournamentName: 'Spring Classic',
+   *   matches: [...],
+   * });
+   * if (result.ok) {
+   *   console.log(`Imported ${result.matchesImported} matches`);
+   * }
+   * ```
+   */
+  async tournamentImport(body) {
+    const wire = await this.#http.request({
+      method: "POST",
+      path: "/partner/tournament-import",
+      body
+    });
+    return new TournamentImportResult(wire);
   }
-  toString() {
-    const direction = this.improved ? "\u2191" : "\u2193";
-    const name = this.memberName ? ` (${this.memberName})` : "";
-    return `${this.id}${name}: ${this.previousRating.toFixed(2)} ${direction} ${this.newRating.toFixed(2)}`;
+  /** Send a test payload to a webhook URL. */
+  async testWebhook(webhookUrl) {
+    const data = await this.#http.request({
+      method: "POST",
+      path: "/partner/webhook-test",
+      body: { webhookUrl }
+    });
+    return data ?? {};
   }
 };
-var SearchResults = class {
-  /** List of players */
-  players;
-  /** Total matching players */
-  total;
-  /** Current page */
-  page;
-  /** Results per page */
-  limit;
-  _client;
-  _filters;
-  constructor(data, client, filters = {}) {
-    this.players = data.players.map((p) => new Player(p, client));
-    this.total = data.total;
-    this.page = data.page;
-    this.limit = data.limit;
-    this._client = client;
-    this._filters = filters;
-  }
-  /** Whether more results are available */
-  get hasMore() {
-    return this.page * this.limit < this.total;
-  }
-  /** Total number of pages */
-  get pages() {
-    return this.limit > 0 ? Math.ceil(this.total / this.limit) : 0;
-  }
-  /** Number of players in current page */
-  get length() {
-    return this.players.length;
-  }
-  /** Get player by index */
-  at(index) {
-    return this.players[index];
-  }
-  /** Iterate over players */
-  [Symbol.iterator]() {
-    return this.players[Symbol.iterator]();
+
+// src/models/sport-rating.ts
+var SportRating = class {
+  /** Primary rating for this sport. */
+  rating;
+  /** Category abbreviation for the primary rating (e.g. `'VO'`). */
+  abbr;
+  #splits;
+  constructor(wire) {
+    this.rating = wire.rating;
+    this.abbr = wire.abbr;
+    this.#splits = new Map(Object.entries(wire.ratingSplits ?? {}));
+    Object.freeze(this);
   }
-  /** Fetch next page of results */
-  async nextPage() {
-    if (!this._client) {
-      throw new Error("Results not connected to client");
-    }
-    if (!this.hasMore) {
-      throw new Error("No more pages");
-    }
-    return this._client.search({
-      ...this._filters,
-      page: this.page + 1
-    });
+  /**
+   * Look up a rating split by key (e.g. `'overall-open'`,
+   * `'singles-12-13'`, `'gender-40+'`). Returns `undefined` if the
+   * player has no rating for that bracket.
+   */
+  get(key) {
+    return this.#splits.get(key);
+  }
+  /** Whether the player has a rating for the given split key. */
+  has(key) {
+    return this.#splits.has(key);
+  }
+  /** Number of rating splits. */
+  get size() {
+    return this.#splits.size;
+  }
+  /** All split keys the player has ratings for. */
+  keys() {
+    return this.#splits.keys();
+  }
+  /** All rating splits the player has. */
+  values() {
+    return this.#splits.values();
+  }
+  /** `[key, split]` pairs for every rating split. */
+  entries() {
+    return this.#splits.entries();
+  }
+  /**
+   * `for (const [key, split] of sportRating) { ... }` — iterate every
+   * rating split the player has in this sport.
+   */
+  [Symbol.iterator]() {
+    return this.#splits.entries();
   }
 };
 
-// src/oauth.ts
-var SCOPES = {
-  "profile:read": "Access your name, location, and verification status",
-  "profile:email": "Access your email address",
-  "rating:read": "View your current rating and rating splits",
-  "rating:history": "View your complete rating history",
-  "match:submit": "Submit match results on your behalf",
-  "webhook:subscribe": "Receive notifications when your rating changes"
-};
-var DEFAULT_SCOPES = ["profile:read", "rating:read"];
-function getAuthorizationUrl(config, scopes = DEFAULT_SCOPES, state) {
-  const baseUrl = config.baseUrl || "https://api-next.vairified.com/api/v1";
-  const scopeSet = new Set(scopes);
-  scopeSet.add("profile:read");
-  const scopeList = Array.from(scopeSet);
-  const params = new URLSearchParams({
-    redirect_uri: config.redirectUri,
-    scope: scopeList.join(","),
-    response_type: "code"
-  });
-  if (state) {
-    params.set("state", state);
+// src/models/member.ts
+var MemberSportMap = class {
+  #sports;
+  constructor(wire) {
+    const entries = Object.entries(wire ?? {}).map(
+      ([code, w]) => [code, new SportRating(w)]
+    );
+    this.#sports = new Map(entries);
+    Object.freeze(this);
   }
-  return `${baseUrl}/partner/oauth/authorize?${params.toString()}`;
-}
-function validateScope(scope) {
-  return scope in SCOPES;
-}
-function describeScope(scope) {
-  return SCOPES[scope] ?? `Unknown scope: ${scope}`;
-}
-function describeScopes(scopes) {
-  return scopes.map((scope) => ({
-    scope,
-    description: describeScope(scope)
-  }));
-}
-function generateState() {
-  const array = new Uint8Array(16);
-  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-    crypto.getRandomValues(array);
-  } else {
-    for (let i = 0; i < array.length; i++) {
-      array[i] = Math.floor(Math.random() * 256);
-    }
+  get(sport) {
+    return this.#sports.get(sport);
   }
-  return Array.from(array).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-
-// src/client.ts
-var ENVIRONMENTS = {
-  production: "https://api-next.vairified.com/api/v1",
-  staging: "https://api-staging.vairified.com/api/v1",
-  local: "http://localhost:3001/api/v1"
-};
-var DEFAULT_BASE_URL = ENVIRONMENTS.production;
-var DEFAULT_TIMEOUT = 3e4;
-var Vairified = class {
-  /** API key */
-  apiKey;
-  /** Base URL */
-  baseUrl;
-  /** Environment name */
-  env;
-  /** Request timeout in ms */
-  timeout;
-  constructor(options = {}) {
-    this.apiKey = options.apiKey || this.getEnvApiKey();
-    if (!this.apiKey) {
-      throw new Error("API key required. Pass apiKey option or set VAIRIFIED_API_KEY env var.");
-    }
-    if (options.baseUrl) {
-      this.baseUrl = options.baseUrl.replace(/\/$/, "");
-      this.env = "production";
-    } else if (options.env) {
-      this.baseUrl = ENVIRONMENTS[options.env];
-      this.env = options.env;
-    } else {
-      const envVar = this.getEnvVar("VAIRIFIED_ENV");
-      const defaultEnv = envVar && envVar in ENVIRONMENTS ? envVar : "production";
-      this.baseUrl = ENVIRONMENTS[defaultEnv] || DEFAULT_BASE_URL;
-      this.env = defaultEnv;
-    }
-    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+  has(sport) {
+    return this.#sports.has(sport);
   }
-  getEnvVar(name) {
-    if (typeof process !== "undefined" && process.env?.[name]) {
-      return process.env[name];
-    }
-    return "";
+  get size() {
+    return this.#sports.size;
   }
-  getEnvApiKey() {
-    return this.getEnvVar("VAIRIFIED_API_KEY");
+  keys() {
+    return this.#sports.keys();
   }
-  getHeaders() {
-    return {
-      "X-API-Key": this.apiKey,
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
+  values() {
+    return this.#sports.values();
   }
-  async handleError(response) {
-    let body;
-    let message;
-    try {
-      body = await response.json();
-      message = body.message || response.statusText;
-    } catch {
-      message = response.statusText;
-    }
-    const status = response.status;
-    if (status === 401) throw new AuthenticationError(message, body);
-    if (status === 404) throw new NotFoundError(message, body);
-    if (status === 429) {
-      const retryAfter = response.headers.get("Retry-After");
-      throw new RateLimitError(
-        message,
-        retryAfter ? Number.parseInt(retryAfter, 10) : void 0,
-        body
-      );
-    }
-    if (status === 400) throw new ValidationError(message, body);
-    throw new VairifiedError(message, status, body);
-  }
-  async request(method, path, options) {
-    let url = `${this.baseUrl}${path}`;
-    if (options?.params) {
-      const searchParams = new URLSearchParams();
-      for (const [key, value] of Object.entries(options.params)) {
-        if (value !== void 0 && value !== null) {
-          searchParams.append(key, String(value));
-        }
-      }
-      const queryString = searchParams.toString();
-      if (queryString) url += `?${queryString}`;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: this.getHeaders(),
-        body: options?.body ? JSON.stringify(options.body) : void 0,
-        signal: controller.signal
-      });
-      if (!response.ok) await this.handleError(response);
-      return await response.json();
-    } finally {
-      clearTimeout(timeoutId);
-    }
+  entries() {
+    return this.#sports.entries();
+  }
+  [Symbol.iterator]() {
+    return this.#sports.entries();
+  }
+};
+var Member = class {
+  memberId;
+  id;
+  firstName;
+  lastName;
+  fullName;
+  displayName;
+  age;
+  city;
+  state;
+  zip;
+  country;
+  gender;
+  status;
+  sport;
+  activeLeagues;
+  email;
+  grantedScopes;
+  constructor(wire) {
+    this.memberId = wire.memberId;
+    this.id = wire.id ?? null;
+    this.firstName = wire.firstName;
+    this.lastName = wire.lastName;
+    this.fullName = wire.fullName;
+    this.displayName = wire.displayName;
+    this.age = wire.age ?? null;
+    this.city = wire.city ?? null;
+    this.state = wire.state ?? null;
+    this.zip = wire.zip ?? null;
+    this.country = wire.country ?? null;
+    this.gender = wire.gender ?? null;
+    this.status = Object.freeze({ ...wire.status });
+    this.sport = new MemberSportMap(wire.sport);
+    this.activeLeagues = wire.activeLeagues ? Object.freeze([...wire.activeLeagues]) : null;
+    this.email = wire.email ?? null;
+    this.grantedScopes = wire.grantedScopes ? Object.freeze([...wire.grantedScopes]) : null;
+    Object.freeze(this);
+  }
+  /** Full name — alias for {@link fullName}, matching common usage. */
+  get name() {
+    return this.fullName;
+  }
+  /** The list of sport codes this player has ratings in. */
+  get sports() {
+    return [...this.sport.keys()];
   }
-  // ---------------------------------------------------------------------------
-  // Member Operations
-  // ---------------------------------------------------------------------------
   /**
-   * Get a connected member by their external ID.
+   * Primary rating for a given sport.
    *
-   * **Requires OAuth Connection**: The player must have connected their
-   * account to your application via OAuth before you can access their data.
-   *
-   * @param playerId - External player ID (vair_mem_xxx format)
-   * @returns Member object with profile and rating data
-   * @throws NotFoundError if member is not found or invalid ID format
-   * @throws ForbiddenError if player has not connected to your app
-   *
-   * @example
-   * ```ts
-   * const member = await client.getMember('vair_mem_0ABC123def456GHI789jk');
-   * console.log(member.name, member.rating);
-   * console.log(member.ratingSplits.open); // Open division rating
-   * console.log(member.grantedScopes); // ['profile:read', 'rating:read']
-   * ```
+   * @param sport Sport code — defaults to `'pickleball'`.
+   * @returns The primary rating value, or `null` if the player has no
+   *   ratings for that sport.
    */
-  async getMember(playerId) {
-    const data = await this.request("GET", "/partner/member", {
-      params: { id: playerId }
-    });
-    return new Member(data, this);
+  ratingFor(sport = "pickleball") {
+    return this.sport.get(sport)?.rating ?? null;
   }
-  // ---------------------------------------------------------------------------
-  // Search Operations
-  // ---------------------------------------------------------------------------
   /**
-   * Search for players.
+   * Get a specific rating split for a sport.
    *
-   * @param filters - Search filters
-   * @returns SearchResults with players and pagination
-   *
-   * @example
-   * ```ts
-   * const results = await client.search({
-   *   city: 'Austin',
-   *   ratingMin: 4.0,
-   *   vairifiedOnly: true,
-   * });
-   *
-   * for (const player of results) {
-   *   console.log(player.name, player.rating);
-   * }
-   *
-   * // Pagination
-   * if (results.hasMore) {
-   *   const nextPage = await results.nextPage();
-   * }
-   * ```
+   * @param key Split key (e.g. `'overall-open'`).
+   * @param sport Sport code — defaults to `'pickleball'`.
    */
-  async search(filters = {}) {
-    const params = {
-      limit: filters.limit ?? 20
-    };
-    if (filters.name) params.member = filters.name;
-    if (filters.city) params.city = filters.city;
-    if (filters.state) params.state = filters.state;
-    if (filters.country) params.country = filters.country;
-    if (filters.zipCode) params.zip = filters.zipCode;
-    if (filters.ratingMin !== void 0) params.rating1 = filters.ratingMin;
-    if (filters.ratingMax !== void 0) params.rating2 = filters.ratingMax;
-    if (filters.gender) params.gender = filters.gender;
-    if (filters.vairifiedOnly) params.vairified = true;
-    if (filters.sortBy) {
-      params.sortField = filters.sortBy;
-      params.sortDirection = filters.sortOrder ?? "desc";
-    }
-    if (filters.age !== void 0) {
-      params.ageFilterType = "exact";
-      params.age1 = filters.age;
-    } else if (filters.ageMin !== void 0 && filters.ageMax !== void 0) {
-      params.ageFilterType = "range";
-      params.age1 = filters.ageMin;
-      params.age2 = filters.ageMax;
-    } else if (filters.ageMin !== void 0) {
-      params.ageFilterType = "above";
-      params.age1 = filters.ageMin;
-    } else if (filters.ageMax !== void 0) {
-      params.ageFilterType = "below";
-      params.age1 = filters.ageMax;
+  split(key, sport = "pickleball") {
+    return this.sport.get(sport)?.get(key) ?? null;
+  }
+  /** Compact summary for console output. */
+  toString() {
+    const primary = this.sport.values().next().value;
+    if (primary) {
+      return `Member #${this.memberId} '${this.displayName}' rating=${primary.rating.toFixed(
+        3
+      )} ${primary.abbr}`;
     }
-    const page = filters.page ?? 1;
-    if (page > 1) {
-      params.offset = (page - 1) * (filters.limit ?? 20);
+    return `Member #${this.memberId} '${this.displayName}'`;
+  }
+};
+
+// src/models/rating-update.ts
+var RatingUpdate = class {
+  memberId;
+  id;
+  displayName;
+  sport;
+  previousRating;
+  newRating;
+  changedAt;
+  ratingSplits;
+  constructor(wire) {
+    this.memberId = wire.memberId;
+    this.id = wire.id ?? null;
+    this.displayName = wire.displayName ?? null;
+    this.sport = wire.sport ?? null;
+    this.previousRating = wire.previousRating ?? null;
+    this.newRating = wire.newRating ?? null;
+    this.changedAt = wire.changedAt ?? null;
+    this.ratingSplits = wire.ratingSplits ? Object.freeze({ ...wire.ratingSplits }) : null;
+    Object.freeze(this);
+  }
+  /**
+   * Rating change amount — `newRating - previousRating`. Returns `null`
+   * if either rating is missing from the update payload.
+   */
+  get delta() {
+    if (this.previousRating === null || this.newRating === null) {
+      return null;
     }
-    const data = await this.request(
-      "GET",
-      "/partner/search",
-      {
-        params
-      }
-    );
-    const normalized = Array.isArray(data) ? { players: data, total: data.length, page, limit: filters.limit ?? 20 } : data;
-    return new SearchResults(normalized, this, filters);
+    return this.newRating - this.previousRating;
+  }
+  /** `true` when the new rating is strictly higher than the previous. */
+  get improved() {
+    const delta = this.delta;
+    return delta !== null && delta > 0;
+  }
+  toString() {
+    const arrow = this.improved ? "\u2191" : "\u2193";
+    const prev = this.previousRating !== null ? this.previousRating.toFixed(3) : "?";
+    const next = this.newRating !== null ? this.newRating.toFixed(3) : "?";
+    const name = this.displayName ? ` '${this.displayName}'` : "";
+    return `RatingUpdate #${this.memberId}${name} ${prev} ${arrow} ${next}`;
+  }
+};
+
+// src/resources/members.ts
+var DEFAULT_PAGE_SIZE = 20;
+var MAX_PAGE_SIZE = 100;
+var MembersResource = class {
+  #http;
+  /** @internal */
+  constructor(http) {
+    this.#http = http;
   }
   /**
-   * Find a single player by name.
+   * Get a connected member by external ID.
+   *
+   * **Requires an active OAuth connection** between your partner app
+   * and the player. Use the OAuth flow on `client.oauth` first.
    *
-   * @param name - Player name to search for
-   * @returns Player if found, undefined otherwise
+   * @param playerId External player ID in `vair_mem_xxx` format.
+   * @param options.sport Optional sport filter — single code or list.
+   *   When omitted, the response contains every sport the player has
+   *   ratings in.
+   * @throws {@link NotFoundError} if the external ID is unknown.
+   * @throws {@link VairifiedError} if the player has not connected to
+   *   your app (403) or the request otherwise fails.
    *
    * @example
    * ```ts
-   * const player = await client.findPlayer('John Smith');
-   * if (player) {
-   *   console.log(player.rating);
-   * }
+   * const member = await client.members.get('vair_mem_xxx');
+   * console.log(member.name, member.ratingFor('pickleball'));
+   *
+   * // Just pickleball
+   * const member2 = await client.members.get('vair_mem_xxx', { sport: 'pickleball' });
+   *
+   * // Multiple sports
+   * const member3 = await client.members.get('vair_mem_xxx', {
+   *   sport: ['pickleball', 'padel'],
+   * });
    * ```
    */
-  async findPlayer(name) {
-    const results = await this.search({ name, limit: 1 });
-    return results.at(0);
+  async get(playerId, options = {}) {
+    const query = { id: playerId };
+    if (options.sport !== void 0) {
+      query.sport = Array.isArray(options.sport) ? options.sport.join(",") : options.sport;
+    }
+    const wire = await this.#http.request({
+      method: "GET",
+      path: "/partner/member",
+      query
+    });
+    return new Member(wire);
   }
-  // ---------------------------------------------------------------------------
-  // Match Operations
-  // ---------------------------------------------------------------------------
   /**
-   * Submit a single match.
+   * Search for members, yielding each match as a {@link Member}.
    *
-   * @param match - Match object with teams and scores
-   * @returns MatchResult with submission status
+   * This is an **auto-paginating async iterator** — it fetches pages
+   * from the server lazily as you iterate, so you can stream through
+   * thousands of results without holding them all in memory:
    *
-   * @example
    * ```ts
-   * const match = new Match({
-   *   event: 'Weekly League',
-   *   bracket: '4.0 Doubles',
-   *   date: new Date(),
-   *   team1: ['p1', 'p2'],
-   *   team2: ['p3', 'p4'],
-   *   scores: [[11, 9], [11, 7]],
-   * });
-   *
-   * const result = await client.submitMatch(match);
-   * if (result.ok) {
-   *   console.log(`Submitted ${result.numGames} games`);
+   * for await (const m of client.members.search({ city: 'Austin' })) {
+   *   console.log(m.name, m.ratingFor('pickleball'));
    * }
    * ```
+   *
+   * Stop early by `break`-ing out of the loop, or cap the total with
+   * `maxResults`.
    */
-  async submitMatch(match) {
-    return this.submitMatches([match]);
+  async *search(filters = {}) {
+    const pageSize = Math.min(filters.pageSize ?? DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
+    const maxResults = filters.maxResults;
+    const baseQuery = buildSearchQuery(filters, pageSize);
+    let offset = 0;
+    let yielded = 0;
+    while (true) {
+      const query = { ...baseQuery, offset };
+      const data = await this.#http.request({ method: "GET", path: "/partner/search", query });
+      const batch = Array.isArray(data) ? data : data?.players ?? [];
+      if (batch.length === 0) {
+        return;
+      }
+      for (const wire of batch) {
+        yield new Member(wire);
+        yielded += 1;
+        if (maxResults !== void 0 && yielded >= maxResults) {
+          return;
+        }
+      }
+      if (batch.length < pageSize) {
+        return;
+      }
+      offset += pageSize;
+    }
   }
   /**
-   * Submit multiple matches in a batch.
+   * Return the first search hit for a name, or `null`.
    *
-   * @param matches - List of Match objects
-   * @returns MatchResult with submission status
+   * Convenience for the common "look up by name" case:
    *
-   * @example
    * ```ts
-   * const result = await client.submitMatches([match1, match2, match3]);
-   * console.log(`Submitted ${result.numGames} games from ${result.numMatches} matches`);
-   *
-   * if (result.dryRun) {
-   *   console.log('This was a dry run - no data persisted');
+   * const mike = await client.members.find('Mike Barker');
+   * if (mike) {
+   *   console.log(mike.ratingFor('pickleball'));
    * }
    * ```
    */
-  async submitMatches(matches) {
-    const data = await this.request("POST", "/partner/matches", {
-      body: { matches: matches.map((m) => m.toJSON()) }
-    });
-    return new MatchResult(data);
+  async find(name) {
+    for await (const member of this.search({ name, pageSize: 1, maxResults: 1 })) {
+      return member;
+    }
+    return null;
   }
-  // ---------------------------------------------------------------------------
-  // Rating Updates
-  // ---------------------------------------------------------------------------
   /**
-   * Get rating updates for subscribed members.
+   * Fetch up to 100 members by their member IDs in one call.
    *
-   * Members are subscribed when you call getMember().
+   * Unknown IDs are silently omitted — the returned array may be
+   * shorter than the input. Results are returned in the same order
+   * as the input IDs.
    *
-   * @returns List of RatingUpdate objects
+   * @param ids - Array of integer member IDs (max 100).
+   * @param options - Optional filters.
+   * @param options.sport - Sport code to scope ratings (e.g. `'pickleball'`).
+   * @returns Array of {@link Member} instances.
+   * @throws {@link ValidationError} If more than 100 IDs are provided.
+   * @category Members
    *
    * @example
    * ```ts
-   * const updates = await client.getRatingUpdates();
-   * for (const update of updates) {
-   *   console.log(`${update.memberId}: ${update.previousRating} → ${update.newRating}`);
-   *   if (update.improved) {
-   *     const member = await update.getMember();
-   *     console.log(`${member.name} improved!`);
-   *   }
+   * const members = await client.members.getBulk([4873327, 4873328]);
+   * for (const m of members) {
+   *   console.log(m.name, m.ratingFor('pickleball'));
    * }
    * ```
    */
-  async getRatingUpdates() {
-    const data = await this.request(
-      "GET",
-      "/partner/rating-updates"
-    );
-    return (data.updates ?? []).map((u) => new RatingUpdate(u, this));
+  async getBulk(ids, options) {
+    if (ids.length > 100) {
+      throw new ValidationError("Maximum 100 member IDs per request");
+    }
+    const query = { ids: ids.join(",") };
+    if (options?.sport) query.sport = options.sport;
+    const rows = await this.#http.request({
+      method: "GET",
+      path: "/partner/members",
+      query
+    });
+    return rows.map((row) => new Member(row));
   }
   /**
-   * Test webhook endpoint.
+   * Poll for rating change notifications.
    *
-   * @param webhookUrl - URL to send test webhook to
-   * @returns Test result
+   * Returns a list of {@link RatingUpdate} objects for every player
+   * whose rating has changed since the last poll. Members are
+   * considered subscribed when they have an active OAuth connection
+   * with the `user:webhook:subscribe` scope.
    */
-  async testWebhook(webhookUrl) {
-    return this.request("POST", "/partner/webhook-test", {
-      body: { webhookUrl }
+  async ratingUpdates() {
+    const data = await this.#http.request({
+      method: "GET",
+      path: "/partner/rating-updates"
     });
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return [];
+    }
+    const updates = data.updates ?? [];
+    return updates.map((wire) => new RatingUpdate(wire));
+  }
+};
+function buildSearchQuery(filters, pageSize) {
+  const query = {};
+  if (filters.sport !== void 0) {
+    query.sport = Array.isArray(filters.sport) ? filters.sport.join(",") : filters.sport;
+  }
+  if (filters.memberId !== void 0) {
+    query.member = String(filters.memberId);
+  } else if (filters.name !== void 0) {
+    query.member = filters.name;
+  }
+  if (filters.city !== void 0) query.city = filters.city;
+  if (filters.state !== void 0) query.state = filters.state;
+  if (filters.country !== void 0) query.country = filters.country;
+  if (filters.zip !== void 0) query.zip = filters.zip;
+  if (filters.location !== void 0) query.location = filters.location;
+  if (filters.gender !== void 0) {
+    query.gender = filters.gender.toUpperCase();
+  }
+  if (filters.vairifiedOnly !== void 0) query.vairified = filters.vairifiedOnly;
+  if (filters.wheelchair !== void 0) query.wheelchair = filters.wheelchair;
+  if (filters.ratingMin !== void 0) query.rating1 = filters.ratingMin;
+  if (filters.ratingMax !== void 0) query.rating2 = filters.ratingMax;
+  const { ageFilterType, age1, age2 } = resolveAgeFilter(filters);
+  if (ageFilterType !== void 0) query.ageFilterType = ageFilterType;
+  if (age1 !== void 0) query.age1 = age1;
+  if (age2 !== void 0) query.age2 = age2;
+  if (filters.sortBy !== void 0) query.sortField = filters.sortBy;
+  if (filters.sortOrder !== void 0) query.sortDirection = filters.sortOrder;
+  query.limit = pageSize;
+  return query;
+}
+function resolveAgeFilter(filters) {
+  if (filters.age !== void 0) {
+    return { ageFilterType: "exact", age1: filters.age };
+  }
+  if (filters.ageMin !== void 0 && filters.ageMax !== void 0) {
+    return { ageFilterType: "range", age1: filters.ageMin, age2: filters.ageMax };
+  }
+  if (filters.ageMin !== void 0) {
+    return { ageFilterType: "above", age1: filters.ageMin };
+  }
+  if (filters.ageMax !== void 0) {
+    return { ageFilterType: "below", age1: filters.ageMax };
+  }
+  return {};
+}
+
+// src/oauth.ts
+var SCOPES = Object.freeze({
+  "user:profile:read": "Access your name, location, and verification status",
+  "user:profile:email": "Access your email address",
+  "user:rating:read": "View your current rating and rating splits",
+  "user:rating:history": "View your complete rating history",
+  "user:match:submit": "Submit match results on your behalf",
+  "user:webhook:subscribe": "Receive notifications when your rating changes"
+});
+var DEFAULT_SCOPES = Object.freeze([
+  "user:profile:read",
+  "user:rating:read"
+]);
+function getAuthorizationUrl(config, options = {}) {
+  const baseUrl = (config.baseUrl ?? "https://api-next.vairified.com/api/v1").replace(/\/+$/, "");
+  const scopeList = ensureProfileRead(options.scopes ?? DEFAULT_SCOPES);
+  const params = new URLSearchParams({
+    redirect_uri: config.redirectUri,
+    scope: scopeList.join(","),
+    response_type: "code"
+  });
+  if (options.state) {
+    params.set("state", options.state);
+  }
+  return `${baseUrl}/partner/oauth/authorize?${params.toString()}`;
+}
+function validateScope(scope) {
+  return scope in SCOPES;
+}
+function describeScope(scope) {
+  if (validateScope(scope)) {
+    return SCOPES[scope];
+  }
+  return `Unknown scope: ${scope}`;
+}
+function describeScopes(scopes) {
+  return scopes.map((scope) => ({
+    scope,
+    description: describeScope(scope)
+  }));
+}
+function generateState() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function ensureProfileRead(scopes) {
+  if (scopes.includes("user:profile:read")) {
+    return scopes;
+  }
+  return ["user:profile:read", ...scopes];
+}
+
+// src/resources/oauth.ts
+var OAuthResource = class {
+  #http;
+  /** @internal */
+  constructor(http) {
+    this.#http = http;
   }
-  // ---------------------------------------------------------------------------
-  // OAuth Operations
-  // ---------------------------------------------------------------------------
   /**
    * Start an OAuth authorization flow.
    *
-   * This creates a pending authorization and returns the URL where
-   * users should be redirected to approve access.
-   *
-   * @param redirectUri - Your application's callback URL
-   * @param scopes - Permission scopes to request (defaults to profile:read, rating:read)
-   * @param state - CSRF protection state parameter (recommended)
-   * @returns AuthorizationResponse with the URL to redirect users to
-   * @throws OAuthError if the authorization fails to start
-   *
-   * @example
-   * ```ts
-   * const auth = await client.startOAuth(
-   *   'https://myapp.com/callback',
-   *   ['profile:read', 'rating:read', 'match:submit'],
-   *   'random_csrf_token',
-   * );
-   * // Redirect user to auth.authorizationUrl
-   * window.location.href = auth.authorizationUrl;
-   * ```
-   *
-   * @category OAuth
+   * @throws {@link OAuthError} with `errorCode: 'invalid_scope'` if a
+   *   requested scope is not in the accepted list.
    */
-  async startOAuth(redirectUri, scopes = [...DEFAULT_SCOPES], state) {
-    const scopeSet = new Set(scopes);
-    scopeSet.add("profile:read");
-    const scopeList = Array.from(scopeSet);
+  async authorize(options) {
+    const scopeList = ensureProfileRead(options.scopes ?? DEFAULT_SCOPES);
     for (const scope of scopeList) {
       if (!(scope in SCOPES)) {
         throw new OAuthError(`Invalid scope: ${scope}`, "invalid_scope");
       }
     }
-    const data = await this.request("POST", "/partner/oauth/authorize", {
+    const data = await this.#http.request({
+      method: "POST",
+      path: "/partner/oauth/authorize",
       body: {
-        redirectUri,
+        redirectUri: options.redirectUri,
         scope: scopeList.join(","),
-        state
+        state: options.state
       }
     });
     return {
-      authorizationUrl: data.authorizationUrl,
-      code: data.code,
-      state
+      authorizationUrl: data?.authorizationUrl ?? "",
+      code: data?.code ?? "",
+      state: options.state
     };
   }
-  /**
-   * Exchange an authorization code for access and refresh tokens.
-   *
-   * Call this after the user approves access and is redirected back
-   * to your application with a code parameter.
-   *
-   * @param code - Authorization code from the callback URL
-   * @param redirectUri - Must match the redirectUri used in startOAuth
-   * @returns TokenResponse with access_token, refresh_token, and player_id
-   * @throws OAuthError if the code is invalid or expired
-   *
-   * @example
-   * ```ts
-   * // After user is redirected to: https://myapp.com/callback?code=xxx
-   * const tokens = await client.exchangeToken(
-   *   new URL(window.location.href).searchParams.get('code')!,
-   *   'https://myapp.com/callback',
-   * );
-   * // Store tokens.accessToken and tokens.refreshToken securely
-   * // Use tokens.playerId to identify the connected player
-   * ```
-   *
-   * @category OAuth
-   */
-  async exchangeToken(code, redirectUri) {
-    const data = await this.request("POST", "/partner/oauth/token", {
-      body: { code, redirectUri }
+  /** Exchange an authorization code for access and refresh tokens. */
+  async exchangeToken(options) {
+    const data = await this.#http.request({
+      method: "POST",
+      path: "/partner/oauth/token",
+      body: { code: options.code, redirectUri: options.redirectUri }
     });
-    return {
-      accessToken: data.accessToken,
-      refreshToken: data.refreshToken,
-      expiresIn: data.expiresIn,
-      scope: data.scope ? data.scope.split(",") : [],
-      playerId: data.playerId
-    };
+    return tokenResponseFromWire(data);
+  }
+  /** Refresh an expired access token using a refresh token. */
+  async refresh(refreshToken) {
+    const data = await this.#http.request({
+      method: "POST",
+      path: "/partner/oauth/refresh",
+      body: { refreshToken }
+    });
+    return tokenResponseFromWire(data);
+  }
+  /** Revoke a player's OAuth connection to your app. */
+  async revoke(playerId) {
+    const data = await this.#http.request({
+      method: "POST",
+      path: "/partner/oauth/revoke",
+      body: { playerId }
+    });
+    return data ?? {};
+  }
+  /** Return the list of OAuth scopes the server currently supports. */
+  async availableScopes() {
+    const data = await this.#http.request({
+      method: "GET",
+      path: "/partner/oauth/scopes"
+    });
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return [];
+    }
+    return data.scopes ?? [];
+  }
+};
+function tokenResponseFromWire(data) {
+  const scopeRaw = data?.scope ?? "";
+  const scopeList = scopeRaw.length > 0 ? scopeRaw.split(",") : [];
+  return {
+    accessToken: data?.accessToken ?? "",
+    refreshToken: data?.refreshToken ?? null,
+    expiresIn: data?.expiresIn ?? 3600,
+    scope: Object.freeze(scopeList),
+    playerId: data?.playerId ?? ""
+  };
+}
+
+// src/models/webhook-delivery.ts
+var WebhookDelivery = class {
+  id;
+  event;
+  url;
+  statusCode;
+  responseBody;
+  errorMessage;
+  attempts;
+  maxAttempts;
+  lastAttemptAt;
+  nextRetryAt;
+  completedAt;
+  createdAt;
+  payload;
+  /** @internal */
+  constructor(wire) {
+    this.id = wire.id;
+    this.event = wire.event;
+    this.url = wire.url;
+    this.statusCode = wire.statusCode;
+    this.responseBody = wire.responseBody;
+    this.errorMessage = wire.errorMessage;
+    this.attempts = wire.attempts;
+    this.maxAttempts = wire.maxAttempts;
+    this.lastAttemptAt = wire.lastAttemptAt;
+    this.nextRetryAt = wire.nextRetryAt;
+    this.completedAt = wire.completedAt;
+    this.createdAt = wire.createdAt;
+    this.payload = Object.freeze({ ...wire.payload });
+    Object.freeze(this);
+  }
+  /** Whether delivery completed successfully (2xx status). */
+  get succeeded() {
+    return this.completedAt != null && this.statusCode != null && this.statusCode >= 200 && this.statusCode < 300;
+  }
+  /** Whether delivery failed definitively (completed with non-2xx). */
+  get failed() {
+    return this.completedAt != null && !this.succeeded;
+  }
+};
+var WebhookDeliveriesResult = class {
+  deliveries;
+  total;
+  /** @internal */
+  constructor(wire) {
+    this.deliveries = Object.freeze(wire.deliveries.map((d) => new WebhookDelivery(d)));
+    this.total = wire.total;
+    Object.freeze(this);
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  #http;
+  /** @internal */
+  constructor(http) {
+    this.#http = http;
   }
   /**
-   * Refresh an expired access token.
-   *
-   * Use this when an access token expires to obtain a new one
-   * without requiring the user to re-authorize.
+   * List recent webhook delivery attempts.
    *
-   * @param refreshToken - The refresh token from a previous token exchange
-   * @returns TokenResponse with new access_token and optionally a new refresh_token
-   * @throws OAuthError if the refresh token is invalid or revoked
+   * @param options - Optional filters and pagination.
+   * @param options.event - Filter by event type (e.g. `'rating.updated'`).
+   * @param options.status - Filter: `'all'`, `'pending'`, `'success'`, or `'failed'`.
+   * @param options.limit - Results per page (1-100, default 20).
+   * @param options.offset - Pagination offset.
+   * @returns {@link WebhookDeliveriesResult} with entries and total.
+   * @category Webhooks
    *
    * @example
    * ```ts
-   * try {
-   *   const newTokens = await client.refreshAccessToken(storedRefreshToken);
-   *   // Update stored tokens
-   * } catch (e) {
-   *   if (e instanceof OAuthError && e.errorCode === 'invalid_grant') {
-   *     // Refresh token revoked, user needs to re-authorize
-   *   }
+   * const result = await client.webhooks.deliveries({ status: 'failed' });
+   * for (const d of result.deliveries) {
+   *   console.log(d.event, d.statusCode, d.errorMessage);
    * }
    * ```
-   *
-   * @category OAuth
    */
-  async refreshAccessToken(refreshToken) {
-    const data = await this.request("POST", "/partner/oauth/refresh", {
-      body: { refreshToken }
+  async deliveries(options) {
+    const query = {};
+    if (options?.event) query.event = options.event;
+    if (options?.status) query.status = options.status;
+    if (options?.limit != null) query.limit = options.limit;
+    if (options?.offset != null) query.offset = options.offset;
+    const data = await this.#http.request({
+      method: "GET",
+      path: "/partner/webhook-deliveries",
+      query
     });
-    return {
-      accessToken: data.accessToken,
-      refreshToken: data.refreshToken,
-      expiresIn: data.expiresIn,
-      scope: data.scope ? data.scope.split(",") : [],
-      playerId: data.playerId
-    };
+    return new WebhookDeliveriesResult(data);
+  }
+};
+
+// src/client.ts
+var ENVIRONMENTS = Object.freeze({
+  production: "https://api-next.vairified.com/api/v1",
+  staging: "https://api-staging.vairified.com/api/v1",
+  local: "http://localhost:3001/api/v1"
+});
+var DEFAULT_TIMEOUT_MS = 3e4;
+var Vairified = class {
+  /** The resolved API key this client is using. */
+  apiKey;
+  /** The resolved base URL (production, staging, local, or custom). */
+  baseUrl;
+  /** The resolved environment name. */
+  env;
+  /** Request timeout in milliseconds. */
+  timeoutMs;
+  /** Member operations — get, search, find, ratingUpdates. */
+  members;
+  /** Match submission — submit, testWebhook. */
+  matches;
+  /** OAuth flow — authorize, exchangeToken, refresh, revoke. */
+  oauth;
+  /** Leaderboard queries — list, rank, categories. */
+  leaderboard;
+  /** Webhook delivery inspection — deliveries. */
+  webhooks;
+  #transport;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env.VAIRIFIED_API_KEY ?? "";
+    if (apiKey.length === 0) {
+      throw new Error("API key required. Pass { apiKey } or set VAIRIFIED_API_KEY.");
+    }
+    this.apiKey = apiKey;
+    if (options.baseUrl) {
+      this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+      this.env = options.env ?? "production";
+    } else {
+      const envName = options.env ?? process.env.VAIRIFIED_ENV ?? "production";
+      if (options.env && !(envName in ENVIRONMENTS)) {
+        throw new Error(
+          `Unknown environment: ${envName}. Use one of: ${Object.keys(ENVIRONMENTS).join(", ")}`
+        );
+      }
+      this.env = envName;
+      this.baseUrl = ENVIRONMENTS[envName] ?? ENVIRONMENTS.production;
+    }
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.#transport = new HttpTransport({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      fetch: options.fetch ?? fetch
+    });
+    this.members = new MembersResource(this.#transport);
+    this.matches = new MatchesResource(this.#transport);
+    this.oauth = new OAuthResource(this.#transport);
+    this.leaderboard = new LeaderboardResource(this.#transport);
+    this.webhooks = new WebhooksResource(this.#transport);
   }
   /**
-   * Revoke a player's OAuth connection.
-   *
-   * This disconnects the player from your application. You will no
-   * longer be able to access their data or submit matches on their behalf.
+   * API usage statistics for the current API key.
    *
-   * @param playerId - The player's external ID (vair_mem_xxx format)
-   * @throws OAuthError if the revocation fails
-   *
-   * @example
-   * ```ts
-   * await client.revokeConnection('vair_mem_0ABC123def456GHI789jk');
-   * // Player is now disconnected
-   * ```
-   *
-   * @category OAuth
+   * Returns rate-limit status, request counts, and quota usage.
    */
-  async revokeConnection(playerId) {
-    await this.request("POST", "/partner/oauth/revoke", {
-      body: { playerId }
+  async usage() {
+    const data = await this.#transport.request({
+      method: "GET",
+      path: "/partner/usage"
     });
+    return data ?? {};
   }
   /**
-   * Get a list of available OAuth scopes.
+   * Release any resources held by the client.
    *
-   * @returns List of scope objects with id, name, and description
-   *
-   * @example
-   * ```ts
-   * const scopes = await client.getAvailableScopes();
-   * for (const scope of scopes) {
-   *   console.log(`${scope.id}: ${scope.description}`);
-   * }
-   * ```
-   *
-   * @category OAuth
+   * The current transport is stateless, so this is a no-op today, but
+   * partners should still call it (or use `await using`) so the SDK
+   * can add connection pooling later without breaking them.
    */
-  async getAvailableScopes() {
-    const data = await this.request("GET", "/partner/oauth/scopes");
-    return data.scopes ?? [];
+  async close() {
   }
   /**
-   * Get API usage statistics for your partner account.
-   *
-   * @returns Usage statistics (requests, limits, etc.)
-   *
-   * @example
-   * ```ts
-   * const usage = await client.getUsage();
-   * console.log(`Requests today: ${usage.requestsToday}`);
-   * console.log(`Rate limit: ${usage.rateLimit}/hour`);
-   * ```
-   *
-   * @category Client
+   * Explicit resource management hook — enables
+   * `await using client = new Vairified({ ... })` (TypeScript 5.2+).
    */
-  async getUsage() {
-    return this.request("GET", "/partner/usage");
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  /** Compact summary for console output. */
+  toString() {
+    return `Vairified { env: '${this.env}', baseUrl: '${this.baseUrl}' }`;
   }
 };
 export {
   AuthenticationError,
   DEFAULT_SCOPES,
-  Match,
-  MatchResult,
+  ENVIRONMENTS,
+  LeaderboardResource,
+  MatchBatchResult,
+  MatchesResource,
   Member,
+  MemberSportMap,
+  MembersResource,
   NotFoundError,
   OAuthError,
-  Player,
+  OAuthResource,
   RateLimitError,
-  RatingSplit,
-  RatingSplits,
   RatingUpdate,
   SCOPES,
-  SearchResults,
+  SportRating,
+  TournamentImportResult,
   Vairified,
   VairifiedError,
   ValidationError,
+  WebhookDeliveriesResult,
+  WebhookDelivery,
+  WebhooksResource,
   describeScope,
   describeScopes,
   generateState,