@voxary/valorant-client 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1495 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MissingContextError: () => MissingContextError,
+  MissingParameterError: () => MissingParameterError,
+  ValorantApiError: () => ValorantApiError,
+  ValorantAuthError: () => ValorantAuthError,
+  ValorantClient: () => ValorantClient,
+  ValorantContext: () => ValorantContext,
+  ValorantError: () => ValorantError,
+  ValorantNetworkError: () => ValorantNetworkError,
+  ValorantRateLimitError: () => ValorantRateLimitError,
+  ValorantValidationError: () => ValorantValidationError,
+  fetchTransport: () => fetchTransport,
+  isRegion: () => isRegion,
+  localTransport: () => localTransport,
+  parseAuthRedirect: () => parseAuthRedirect,
+  parseLockfile: () => parseLockfile,
+  readLockfile: () => readLockfile,
+  registry: () => registry,
+  shardForRegion: () => shardForRegion
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_zod4 = require("zod");
+
+// src/api/registry.ts
+var import_valorant_api_types = require("valorant-api-types");
+
+// src/extra/catalog.ts
+var import_zod = require("zod");
+
+// src/envelope.ts
+var enveloped = /* @__PURE__ */ new WeakSet();
+function markEnveloped(endpoint2) {
+  enveloped.add(endpoint2);
+  return endpoint2;
+}
+function unwrapEnvelope(endpoint2, body) {
+  if (enveloped.has(endpoint2) && typeof body === "object" && body !== null && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+
+// src/extra/catalog.ts
+var BASE = "https://valorant-api.com/v1/";
+var text = import_zod.z.string().nullish();
+var asset = import_zod.z.object({
+  uuid: import_zod.z.string(),
+  displayName: text,
+  displayIcon: text,
+  assetPath: text
+}).passthrough();
+var agentSchema = asset.extend({
+  description: text,
+  developerName: text,
+  characterTags: import_zod.z.array(import_zod.z.string()).nullish(),
+  displayIconSmall: text,
+  bustPortrait: text,
+  fullPortrait: text,
+  killfeedPortrait: text,
+  background: text,
+  isPlayableCharacter: import_zod.z.boolean(),
+  role: import_zod.z.object({ uuid: import_zod.z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: import_zod.z.array(import_zod.z.object({ slot: import_zod.z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+});
+var mapSchema = asset.extend({
+  coordinates: text,
+  listViewIcon: text,
+  splash: text,
+  mapUrl: text,
+  xMultiplier: import_zod.z.number(),
+  yMultiplier: import_zod.z.number(),
+  xScalarToAdd: import_zod.z.number(),
+  yScalarToAdd: import_zod.z.number(),
+  callouts: import_zod.z.array(import_zod.z.object({ regionName: import_zod.z.string(), superRegionName: import_zod.z.string(), location: import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }) }).passthrough()).nullish()
+});
+var weaponSchema = asset.extend({
+  category: import_zod.z.string(),
+  defaultSkinUuid: import_zod.z.string(),
+  killStreamIcon: text,
+  weaponStats: import_zod.z.object({}).passthrough().nullish(),
+  shopData: import_zod.z.object({}).passthrough().nullish(),
+  skins: import_zod.z.array(import_zod.z.object({}).passthrough())
+});
+var skinSchema = asset.extend({
+  themeUuid: import_zod.z.string(),
+  contentTierUuid: text,
+  wallpaper: text,
+  chromas: import_zod.z.array(asset.passthrough()),
+  levels: import_zod.z.array(asset.passthrough())
+});
+var seasonSchema = import_zod.z.object({
+  uuid: import_zod.z.string(),
+  displayName: text,
+  type: text,
+  startTime: import_zod.z.string(),
+  endTime: import_zod.z.string(),
+  parentUuid: text,
+  assetPath: text
+}).passthrough();
+var versionSchema = import_zod.z.object({
+  manifestId: import_zod.z.string(),
+  branch: import_zod.z.string(),
+  version: import_zod.z.string(),
+  buildVersion: import_zod.z.string(),
+  engineVersion: import_zod.z.string(),
+  riotClientVersion: import_zod.z.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: import_zod.z.string(),
+  buildDate: import_zod.z.string()
+}).passthrough();
+function query(extra = []) {
+  return new Map([
+    ["language", import_zod.z.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
+    ...extra
+  ]);
+}
+function endpoint(name, description, path, schema, extra = []) {
+  return markEnveloped({
+    name,
+    description,
+    category: "Valorant-API.com",
+    type: "other",
+    suffix: `${BASE}${path}`,
+    query: query(extra),
+    responses: { "200": schema }
+  });
+}
+function collection(title, singular, path, schema, extra = []) {
+  return {
+    list: endpoint(title, `List of ${title.toLowerCase()}`, path, import_zod.z.array(schema), extra),
+    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
+  };
+}
+var playable = [["isPlayableCharacter", import_zod.z.boolean().optional().describe("Only return playable agents. Skips the duplicate Sova.")]];
+var agents = collection("Agents", "Agent", "agents", agentSchema, playable);
+var buddies = collection("Buddies", "Buddy", "buddies", asset);
+var buddyLevels = collection("Buddy Levels", "Buddy Level", "buddies/levels", asset);
+var bundles = collection("Bundles", "Bundle", "bundles", asset);
+var ceremonies = collection("Ceremonies", "Ceremony", "ceremonies", asset);
+var competitiveTiers = collection("Competitive Tiers", "Competitive Tier Set", "competitivetiers", import_zod.z.object({ uuid: import_zod.z.string(), tiers: import_zod.z.array(import_zod.z.object({ tier: import_zod.z.number(), tierName: text, division: text, color: text }).passthrough()) }).passthrough());
+var contentTiers = collection("Content Tiers", "Content Tier", "contenttiers", asset);
+var contracts = collection("Contracts", "Contract", "contracts", asset);
+var currencies = collection("Currencies", "Currency", "currencies", asset);
+var events = collection("Events", "Event", "events", asset);
+var flex = collection("Flex", "Flex Item", "flex", asset);
+var gamemodes = collection("Gamemodes", "Gamemode", "gamemodes", asset);
+var gamemodeEquippables = collection("Gamemode Equippables", "Gamemode Equippable", "gamemodes/equippables", asset);
+var gear = collection("Gear", "Gear Item", "gear", asset);
+var levelBorders = collection("Level Borders", "Level Border", "levelborders", asset);
+var maps = collection("Maps", "Map", "maps", mapSchema);
+var missions = collection("Missions", "Mission", "missions", import_zod.z.object({ uuid: import_zod.z.string(), displayName: text }).passthrough());
+var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", import_zod.z.object({ uuid: import_zod.z.string(), displayName: text, titleText: text }).passthrough());
+var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", import_zod.z.object({ uuid: import_zod.z.string(), seasonUuid: import_zod.z.string(), startTime: import_zod.z.string(), endTime: import_zod.z.string() }).passthrough());
+var sprays = collection("Sprays", "Spray", "sprays", asset);
+var sprayLevels = collection("Spray Levels", "Spray Level", "sprays/levels", asset);
+var themes = collection("Themes", "Theme", "themes", asset);
+var weapons = collection("Weapons", "Weapon", "weapons", weaponSchema);
+var weaponSkins = collection("Weapon Skins", "Weapon Skin", "weapons/skins", skinSchema);
+var weaponSkinChromas = collection("Weapon Skin Chromas", "Weapon Skin Chroma", "weapons/skinchromas", asset);
+var weaponSkinLevels = collection("Weapon Skin Levels", "Weapon Skin Level", "weapons/skinlevels", asset);
+var catalogEndpoints = {
+  agents: agents.list,
+  agent: agents.one,
+  buddies: buddies.list,
+  buddy: buddies.one,
+  buddyLevels: buddyLevels.list,
+  buddyLevel: buddyLevels.one,
+  bundles: bundles.list,
+  bundle: bundles.one,
+  ceremonies: ceremonies.list,
+  ceremony: ceremonies.one,
+  competitiveTiers: competitiveTiers.list,
+  competitiveTier: competitiveTiers.one,
+  contentTiers: contentTiers.list,
+  contentTier: contentTiers.one,
+  contracts: contracts.list,
+  contract: contracts.one,
+  currencies: currencies.list,
+  currency: currencies.one,
+  events: events.list,
+  event: events.one,
+  flex: flex.list,
+  flexItem: flex.one,
+  gamemodes: gamemodes.list,
+  gamemode: gamemodes.one,
+  gamemodeEquippables: gamemodeEquippables.list,
+  gamemodeEquippable: gamemodeEquippables.one,
+  gear: gear.list,
+  gearItem: gear.one,
+  levelBorders: levelBorders.list,
+  levelBorder: levelBorders.one,
+  maps: maps.list,
+  map: maps.one,
+  missions: missions.list,
+  mission: missions.one,
+  playerCards: playerCards.list,
+  playerCard: playerCards.one,
+  playerTitles: playerTitles.list,
+  playerTitle: playerTitles.one,
+  seasons: seasons.list,
+  season: seasons.one,
+  competitiveSeasons: competitiveSeasons.list,
+  competitiveSeason: competitiveSeasons.one,
+  sprays: sprays.list,
+  spray: sprays.one,
+  sprayLevels: sprayLevels.list,
+  sprayLevel: sprayLevels.one,
+  themes: themes.list,
+  theme: themes.one,
+  version: endpoint("Version", "Current game version and the matching client version", "version", versionSchema),
+  weapons: weapons.list,
+  weapon: weapons.one,
+  weaponSkins: weaponSkins.list,
+  weaponSkin: weaponSkins.one,
+  weaponSkinChromas: weaponSkinChromas.list,
+  weaponSkinChroma: weaponSkinChromas.one,
+  weaponSkinLevels: weaponSkinLevels.list,
+  weaponSkinLevel: weaponSkinLevels.one
+};
+
+// src/extra/riot.ts
+var import_zod2 = require("zod");
+var contractsActiveStoryEndpoint = {
+  name: "Active Story",
+  description: "Get the battlepass contracts",
+  queryName: "ContractDefinitions_FetchActiveStory",
+  category: "Contract Endpoints",
+  type: "pd",
+  suffix: "contract-definitions/v2/definitions/story",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var currentGameAllChatTokenEndpoint = {
+  name: "All Chat Token",
+  description: "Get a token for all chat",
+  queryName: "CoreGame_FetchAllChatMUCToken",
+  category: "Current Game Endpoints",
+  type: "glz",
+  suffix: "core-game/v1/matches/{in-progress match id}/allchatmuctoken",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var currentGameTeamChatTokenEndpoint = {
+  name: "Team Chat Token",
+  description: "Get a token for team chat",
+  queryName: "CoreGame_FetchTeamChatMUCToken",
+  category: "Current Game Endpoints",
+  type: "glz",
+  suffix: "core-game/v1/matches/{in-progress match id}/teamchatmuctoken",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localAntiAddictionShutdownEndpoint = {
+  name: "Anti Addiction Shutdown",
+  description: "GET ANTI_ADDICTION_RNet_FetchShutdownPolicyState",
+  queryName: "ANTI_ADDICTION_RNet_FetchShutdownPolicyState",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "anti-addiction/v1/products/valorant/policies/shutdown/anti-addiction-state",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localAntiAddictionWarningEndpoint = {
+  name: "Anti Addiction Warning",
+  description: "GET ANTI_ADDICTION_RNet_FetchWarningMessagePolicyState",
+  queryName: "ANTI_ADDICTION_RNet_FetchWarningMessagePolicyState",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "anti-addiction/v1/products/valorant/policies/warningMessage/anti-addiction-state",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localClientConfigEndpoint = {
+  name: "Client Config",
+  description: "GET CLIENTCONFIG_RNET_GET_ValorantClientConfig",
+  queryName: "CLIENTCONFIG_RNET_GET_ValorantClientConfig",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "client-config/v2/namespace/valorant.client/player",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localEulaEndpoint = {
+  name: "Eula",
+  description: "Get the EULA",
+  queryName: "LEGAL_INFO_RNet_EULA",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/agreement/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localPrivacyPolicyEndpoint = {
+  name: "Privacy Policy",
+  description: "Get privacy policy",
+  queryName: "LEGAL_INFO_RNet_Privacy",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/privacy-policy/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localAvailableLocalesEndpoint = {
+  name: "Available Locales",
+  description: "Get available locales",
+  queryName: "LOCALE_RNet_FetchAvailableLocales",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "rnet-product-registry/v4/available-product-locales/products/valorant/patchlines/live",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localLocaleEndpoint = {
+  name: "Locale",
+  description: "Get the current locale",
+  queryName: "LOCALE_RNet_FetchLocale",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riotclient/product-locales/products/valorant/patchlines/live",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localReporterFeedbackEndpoint = {
+  name: "Reporter Feedback",
+  description: "GET REPORTER_FEEDBACK_RNet_GetReporterFeedback",
+  queryName: "REPORTER_FEEDBACK_RNet_GetReporterFeedback",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "player-reporting/v1/reporter-feedback",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localCommandLineArgsEndpoint = {
+  name: "Command Line Args",
+  description: "Gets the command-line args provided to the Riot client",
+  queryName: "Riot Client Command-Line Args",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riotclient/command-line-args",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localRiotStatusEndpoint = {
+  name: "Riot Status",
+  description: "Get game status information such as maintenances and incidents Response is an escaped JSON string.",
+  queryName: "RiotStatus_RNet_FetchStatus",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riot-status/v1/products/valorant/patchlines/live/deployments/{region}",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localRiotWarningEndpoint = {
+  name: "Riot Warning",
+  description: "GET RIOT_WARNING_RNet_GetRiotWarning",
+  queryName: "RIOT_WARNING_RNet_GetRiotWarning",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "ga-warning/v1/warnings",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localClientAuthorizationsEndpoint = {
+  name: "Client Authorizations",
+  description: "Gets tokens in use by the client",
+  queryName: "RSO_RNet_FetchClientAuthorizations",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "rso-auth/v2/authorizations/valorant-client",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localAccessTokenEndpoint = {
+  name: "Access Token",
+  description: "Gets a Riot access token",
+  queryName: "RSO_RNet_GetAccessToken",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "rso-auth/v1/authorization/access-token",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localUserInfoTokenEndpoint = {
+  name: "User Info Token",
+  description: "GET RSO_RNet_GetUserInfoToken",
+  queryName: "RSO_RNet_GetUserInfoToken",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "rso-auth/v1/userinfo/valorant-client",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var chatSettingsEndpoint = {
+  name: "Settings",
+  description: "Get chat settings",
+  queryName: "TEXT_CHAT_RNet_FetchSettings",
+  category: "Local Endpoints - Chat",
+  type: "local",
+  suffix: "chat/v1/settings",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var chatTournamentInfoEndpoint = {
+  name: "Tournament Info",
+  description: "Get in-tournament conversations",
+  queryName: "TEXT_CHAT_RNet_GetMUCInfos - tournaments",
+  category: "Local Endpoints - Chat",
+  type: "local",
+  suffix: "chat/v6/conversations/ares-tournaments",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localPluginStatusEndpoint = {
+  name: "Plugin Status",
+  description: "Gets plugin status",
+  queryName: "URNetClient_CheckPluginStatus",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "plugin-manager/v1/status",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localRmsSessionEndpoint = {
+  name: "Rms Session",
+  description: "Gets the token for Riot Messaging Service",
+  queryName: "URNetClient_CheckRMSSession",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riot-messaging-service/v1/session",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localProcessInfoEndpoint = {
+  name: "Process Info",
+  description: "Gets the Valorant process ID",
+  queryName: "URNetClient_GetProcessInfo",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "process-control/v1/process",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localLogPathEndpoint = {
+  name: "Log Path",
+  description: "Gets the Valorant log path",
+  queryName: "Valorant Log Path",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "product-session/v1/logs/path/VALORANT",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var voiceAudioPropertiesEndpoint = {
+  name: "Audio Properties",
+  description: "Get audio properties such as if the microphone is in use",
+  queryName: "VOICE_CHAT_RNet_FetchAudioProperties",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v1/audio-properties",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var voiceCaptureDevicesEndpoint = {
+  name: "Capture Devices",
+  description: "Get microphone input device info",
+  queryName: "VOICE_CHAT_RNet_FetchCaptureDevices",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v2/devices/capture",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var voicePushToTalkEndpoint = {
+  name: "Push To Talk",
+  description: "GET VOICE_CHAT_RNet_FetchPTTSettings",
+  queryName: "VOICE_CHAT_RNet_FetchPTTSettings",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v2/push-to-talk/valorant",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var voiceRenderDevicesEndpoint = {
+  name: "Render Devices",
+  description: "Get audio output devices",
+  queryName: "VOICE_CHAT_RNet_FetchRenderDevices",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v2/devices/render",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var voiceSessionsEndpoint = {
+  name: "Sessions",
+  description: "GET VOICE_CHAT_RNet_FetchSessions",
+  queryName: "VOICE_CHAT_RNet_FetchSessions",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v3/sessions/valorant",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var voiceSettingsEndpoint = {
+  name: "Settings",
+  description: "GET VOICE_CHAT_RNet_FetchSettings",
+  queryName: "VOICE_CHAT_RNet_FetchSettings",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v3/settings/valorant",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var pregameChatTokenEndpoint = {
+  name: "Chat Token",
+  description: "Get a chat token",
+  queryName: "Pregame_FetchChatToken",
+  category: "Pre-Game Endpoints",
+  type: "glz",
+  suffix: "pregame/v1/matches/{pre-game match id}/chattoken",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var pregameVoiceTokenEndpoint = {
+  name: "Voice Token",
+  description: "Get a voice token",
+  queryName: "Pregame_FetchVoiceToken",
+  category: "Pre-Game Endpoints",
+  type: "glz",
+  suffix: "pregame/v1/matches/{pre-game match id}/voicetoken",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var sessionGetEndpoint = {
+  name: "Get",
+  description: "Get information about the current game session",
+  queryName: "Session_Get",
+  category: "Session Endpoints",
+  type: "glz",
+  suffix: "session/v1/sessions/{puuid}",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var sessionReconnectEndpoint = {
+  name: "Reconnect",
+  description: "GET Session_ReConnect",
+  queryName: "Session_ReConnect",
+  category: "Session Endpoints",
+  type: "glz",
+  suffix: "session/v1/sessions/{puuid}/reconnect",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var storeOrderEndpoint = {
+  name: "Order",
+  description: "GET Store_GetOrder",
+  queryName: "Store_GetOrder",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/order/{order id}",
+  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+var localPlayerSettingsEndpoint = {
+  name: "Player Settings",
+  description: "Get client settings",
+  queryName: "RiotKV_RNet_GetSettings",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "player-preferences/v1/data-json/Ares.PlayerSettings",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.unknown() }
+};
+
+// src/extra/store.ts
+var import_zod3 = require("zod");
+var offerSchema = import_zod3.z.object({
+  OfferID: import_zod3.z.string(),
+  IsDirectPurchase: import_zod3.z.boolean(),
+  StartDate: import_zod3.z.string(),
+  Cost: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
+  Rewards: import_zod3.z.array(import_zod3.z.object({
+    ItemTypeID: import_zod3.z.string(),
+    ItemID: import_zod3.z.string(),
+    Quantity: import_zod3.z.number()
+  }).passthrough())
+}).passthrough();
+var bundleSchema = import_zod3.z.object({
+  ID: import_zod3.z.string(),
+  DataAssetID: import_zod3.z.string(),
+  CurrencyID: import_zod3.z.string(),
+  Items: import_zod3.z.array(import_zod3.z.unknown()),
+  ItemOffers: import_zod3.z.array(import_zod3.z.unknown()).nullish(),
+  TotalBaseCost: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()).nullish(),
+  TotalDiscountedCost: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()).nullish(),
+  TotalDiscountPercent: import_zod3.z.number(),
+  DurationRemainingInSeconds: import_zod3.z.number(),
+  WholesaleOnly: import_zod3.z.boolean()
+}).passthrough();
+var storefrontV3Endpoint = {
+  name: "Storefront V3",
+  description: "Get the current storefront of the player: featured bundles, the daily skin offers, accessories and night market plugins. Replaces the v2 storefront endpoint, which now answers 404.",
+  queryName: "Store_GetStorefrontV3",
+  category: "Store Endpoints",
+  type: "pd",
+  method: "POST",
+  suffix: "store/v3/storefront/{puuid}",
+  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
+  riotRequirements: {
+    token: true,
+    entitlement: true,
+    clientPlatform: true,
+    clientVersion: true
+  },
+  responses: {
+    "200": import_zod3.z.object({
+      FeaturedBundle: import_zod3.z.object({
+        Bundle: bundleSchema,
+        Bundles: import_zod3.z.array(bundleSchema),
+        BundleRemainingDurationInSeconds: import_zod3.z.number()
+      }).passthrough(),
+      SkinsPanelLayout: import_zod3.z.object({
+        SingleItemOffers: import_zod3.z.array(import_zod3.z.string()),
+        SingleItemStoreOffers: import_zod3.z.array(offerSchema),
+        SingleItemOffersRemainingDurationInSeconds: import_zod3.z.number()
+      }).passthrough(),
+      UpgradeCurrencyStore: import_zod3.z.object({
+        UpgradeCurrencyOffers: import_zod3.z.array(import_zod3.z.object({ OfferID: import_zod3.z.string(), StorefrontItemID: import_zod3.z.string() }).passthrough())
+      }).passthrough(),
+      AccessoryStore: import_zod3.z.object({
+        AccessoryStoreOffers: import_zod3.z.array(import_zod3.z.object({ Offer: offerSchema, ContractID: import_zod3.z.string() }).passthrough()),
+        AccessoryStoreRemainingDurationInSeconds: import_zod3.z.number(),
+        StorefrontID: import_zod3.z.string()
+      }).passthrough(),
+      BonusStore: import_zod3.z.object({
+        BonusStoreOffers: import_zod3.z.array(import_zod3.z.unknown()),
+        BonusStoreRemainingDurationInSeconds: import_zod3.z.number()
+      }).passthrough().optional().describe("Only present while the night market is active"),
+      PluginStores: import_zod3.z.array(import_zod3.z.object({ PluginID: import_zod3.z.string(), PluginOffers: import_zod3.z.unknown(), StartDate: import_zod3.z.string() }).passthrough()).optional()
+    }).passthrough()
+  }
+};
+
+// src/api/registry.ts
+var registry = {
+  pvp: {
+    content: import_valorant_api_types.endpoints.fetchContentEndpoint,
+    accountXp: import_valorant_api_types.endpoints.accountXPEndpoint,
+    playerLoadout: import_valorant_api_types.endpoints.playerLoadoutEndpoint,
+    setPlayerLoadout: import_valorant_api_types.endpoints.setPlayerLoadoutEndpoint,
+    playerMmr: import_valorant_api_types.endpoints.playerMMREndpoint,
+    matchHistory: import_valorant_api_types.endpoints.matchHistoryEndpoint,
+    matchDetails: import_valorant_api_types.endpoints.matchDetailsEndpoint,
+    competitiveUpdates: import_valorant_api_types.endpoints.competitiveUpdatesEndpoint,
+    leaderboard: import_valorant_api_types.endpoints.leaderboardEndpoint,
+    penalties: import_valorant_api_types.endpoints.penaltiesEndpoint,
+    config: import_valorant_api_types.endpoints.configEndpoint,
+    nameService: import_valorant_api_types.endpoints.nameServiceEndpoint
+  },
+  party: {
+    get: import_valorant_api_types.endpoints.partyEndpoint,
+    player: import_valorant_api_types.endpoints.partyPlayerEndpoint,
+    removePlayer: import_valorant_api_types.endpoints.partyRemovePlayerEndpoint,
+    setMemberReady: import_valorant_api_types.endpoints.partySetMemberReadyEndpoint,
+    refreshCompetitiveTier: import_valorant_api_types.endpoints.refreshCompetitiveTierEndpoint,
+    refreshPlayerIdentity: import_valorant_api_types.endpoints.refreshPlayerIdentityEndpoint,
+    refreshPings: import_valorant_api_types.endpoints.refreshPingsEndpoint,
+    changeQueue: import_valorant_api_types.endpoints.changeQueueEndpoint,
+    startCustomGame: import_valorant_api_types.endpoints.startCustomGameEndpoint,
+    enterMatchmakingQueue: import_valorant_api_types.endpoints.enterMatchmakingQueueEndpoint,
+    leaveMatchmakingQueue: import_valorant_api_types.endpoints.leaveMatchmakingQueueEndpoint,
+    setAccessibility: import_valorant_api_types.endpoints.setPartyAccessibilityEndpoint,
+    setCustomGameSettings: import_valorant_api_types.endpoints.setCustomGameSettingsEndpoint,
+    invite: import_valorant_api_types.endpoints.partyInviteEndpoint,
+    requestToJoin: import_valorant_api_types.endpoints.partyRequestEndpoint,
+    declineRequest: import_valorant_api_types.endpoints.partyDeclineEndpoint,
+    customGameConfigs: import_valorant_api_types.endpoints.customGameConfigsEndpoint,
+    chatToken: import_valorant_api_types.endpoints.partyChatTokenEndpoint,
+    voiceToken: import_valorant_api_types.endpoints.partyVoiceTokenEndpoint,
+    disableCode: import_valorant_api_types.endpoints.partyDisableCodeEndpoint,
+    generateCode: import_valorant_api_types.endpoints.partyGenerateCodeEndpoint,
+    joinByCode: import_valorant_api_types.endpoints.partyJoinByCodeEndpoint
+  },
+  store: {
+    prices: import_valorant_api_types.endpoints.pricesEndpoint,
+    storefront: import_valorant_api_types.endpoints.storefrontEndpoint,
+    wallet: import_valorant_api_types.endpoints.walletEndpoint,
+    ownedItems: import_valorant_api_types.endpoints.ownedItemsEndpoint,
+    storefrontV3: storefrontV3Endpoint,
+    order: storeOrderEndpoint
+  },
+  pregame: {
+    player: import_valorant_api_types.endpoints.pregamePlayerEndpoint,
+    match: import_valorant_api_types.endpoints.pregameMatchEndpoint,
+    loadouts: import_valorant_api_types.endpoints.pregameLoadoutsEndpoint,
+    selectCharacter: import_valorant_api_types.endpoints.selectCharacterEndpoint,
+    lockCharacter: import_valorant_api_types.endpoints.lockCharacterEndpoint,
+    quit: import_valorant_api_types.endpoints.pregameQuitEndpoint,
+    chatToken: pregameChatTokenEndpoint,
+    voiceToken: pregameVoiceTokenEndpoint
+  },
+  currentGame: {
+    player: import_valorant_api_types.endpoints.currentGamePlayerEndpoint,
+    match: import_valorant_api_types.endpoints.currentGameMatchEndpoint,
+    loadouts: import_valorant_api_types.endpoints.currentGameLoadoutsEndpoint,
+    quit: import_valorant_api_types.endpoints.currentGameQuitEndpoint,
+    allChatToken: currentGameAllChatTokenEndpoint,
+    teamChatToken: currentGameTeamChatTokenEndpoint
+  },
+  contracts: {
+    itemUpgrades: import_valorant_api_types.endpoints.itemUpgradesEndpoint,
+    list: import_valorant_api_types.endpoints.contractsEndpoint,
+    activate: import_valorant_api_types.endpoints.activateContractEndpoint,
+    activeStory: contractsActiveStoryEndpoint
+  },
+  local: {
+    help: import_valorant_api_types.endpoints.localHelpEndpoint,
+    sessions: import_valorant_api_types.endpoints.sessionsEndpoint,
+    rsoUserInfo: import_valorant_api_types.endpoints.rsoUserInfoEndpoint,
+    clientRegion: import_valorant_api_types.endpoints.clientRegionEndpoint,
+    accountAlias: import_valorant_api_types.endpoints.accountAliasEndpoint,
+    entitlementsToken: import_valorant_api_types.endpoints.entitlementsTokenEndpoint,
+    chatSession: import_valorant_api_types.endpoints.chatSessionEndpoint,
+    friends: import_valorant_api_types.endpoints.friendsEndpoint,
+    sendFriendRequest: import_valorant_api_types.endpoints.sendFriendRequestEndpoint,
+    removeFriendRequest: import_valorant_api_types.endpoints.removeFriendRequestEndpoint,
+    presence: import_valorant_api_types.endpoints.presenceEndpoint,
+    friendRequests: import_valorant_api_types.endpoints.friendRequestsEndpoint,
+    swaggerDocs: import_valorant_api_types.endpoints.localSwaggerDocsEndpoint,
+    antiAddictionShutdown: localAntiAddictionShutdownEndpoint,
+    antiAddictionWarning: localAntiAddictionWarningEndpoint,
+    clientConfig: localClientConfigEndpoint,
+    eula: localEulaEndpoint,
+    privacyPolicy: localPrivacyPolicyEndpoint,
+    availableLocales: localAvailableLocalesEndpoint,
+    locale: localLocaleEndpoint,
+    reporterFeedback: localReporterFeedbackEndpoint,
+    commandLineArgs: localCommandLineArgsEndpoint,
+    riotStatus: localRiotStatusEndpoint,
+    riotWarning: localRiotWarningEndpoint,
+    clientAuthorizations: localClientAuthorizationsEndpoint,
+    accessToken: localAccessTokenEndpoint,
+    userInfoToken: localUserInfoTokenEndpoint,
+    pluginStatus: localPluginStatusEndpoint,
+    rmsSession: localRmsSessionEndpoint,
+    processInfo: localProcessInfoEndpoint,
+    logPath: localLogPathEndpoint,
+    playerSettings: localPlayerSettingsEndpoint
+  },
+  chat: {
+    partyInfo: import_valorant_api_types.endpoints.partyChatInfoEndpoint,
+    pregameInfo: import_valorant_api_types.endpoints.pregameChatInfoEndpoint,
+    currentGameInfo: import_valorant_api_types.endpoints.currentGameChatInfoEndpoint,
+    allInfo: import_valorant_api_types.endpoints.allChatInfoEndpoint,
+    participants: import_valorant_api_types.endpoints.chatParticipantsEndpoint,
+    send: import_valorant_api_types.endpoints.sendChatEndpoint,
+    history: import_valorant_api_types.endpoints.chatHistoryEndpoint,
+    settings: chatSettingsEndpoint,
+    tournamentInfo: chatTournamentInfoEndpoint
+  },
+  session: {
+    get: sessionGetEndpoint,
+    reconnect: sessionReconnectEndpoint
+  },
+  voice: {
+    audioProperties: voiceAudioPropertiesEndpoint,
+    captureDevices: voiceCaptureDevicesEndpoint,
+    renderDevices: voiceRenderDevicesEndpoint,
+    pushToTalk: voicePushToTalkEndpoint,
+    sessions: voiceSessionsEndpoint,
+    settings: voiceSettingsEndpoint
+  },
+  auth: {
+    cookies: import_valorant_api_types.endpoints.authCookiesEndpoint,
+    request: import_valorant_api_types.endpoints.authRequestEndpoint,
+    multiFactor: import_valorant_api_types.endpoints.multiFactorAuthenticationEndpoint,
+    cookieReauth: import_valorant_api_types.endpoints.cookieReauthEndpoint,
+    entitlement: import_valorant_api_types.endpoints.entitlementEndpoint,
+    playerInfo: import_valorant_api_types.endpoints.playerInfoEndpoint,
+    riotGeo: import_valorant_api_types.endpoints.riotGeoEndpoint,
+    pasToken: import_valorant_api_types.endpoints.pasTokenEndpoint,
+    riotClientConfig: import_valorant_api_types.endpoints.riotClientConfigEndpoint
+  },
+  catalog: catalogEndpoints
+};
+
+// src/auth.ts
+var import_valorant_api_types2 = require("valorant-api-types");
+
+// src/errors.ts
+var ValorantError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var MissingContextError = class extends ValorantError {
+  constructor(key) {
+    super(`Context value "${key}" is required for this request but is not set`);
+    this.key = key;
+  }
+  key;
+};
+var MissingParameterError = class extends ValorantError {
+  constructor(parameter, endpoint2) {
+    super(`Path parameter "${parameter}" is required for "${endpoint2}"`);
+    this.parameter = parameter;
+    this.endpoint = endpoint2;
+  }
+  parameter;
+  endpoint;
+};
+var ValorantNetworkError = class extends ValorantError {
+  constructor(message, url, options) {
+    super(message, options);
+    this.url = url;
+  }
+  url;
+};
+var ValorantValidationError = class extends ValorantError {
+  constructor(target, endpoint2, issues, data) {
+    super(`Invalid ${target} for "${endpoint2}": ${issues.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).slice(0, 5).join("; ")}`);
+    this.target = target;
+    this.endpoint = endpoint2;
+    this.issues = issues;
+    this.data = data;
+  }
+  target;
+  endpoint;
+  issues;
+  data;
+};
+var ValorantApiError = class extends ValorantError {
+  constructor(status, endpoint2, url, body, headers) {
+    const code = extractErrorCode(body);
+    super(`${endpoint2} failed with HTTP ${status}${code ? ` (${code})` : ""}`);
+    this.status = status;
+    this.endpoint = endpoint2;
+    this.url = url;
+    this.body = body;
+    this.headers = headers;
+    this.errorCode = code;
+  }
+  status;
+  endpoint;
+  url;
+  body;
+  headers;
+  errorCode;
+};
+var ValorantAuthError = class extends ValorantApiError {
+};
+var ValorantRateLimitError = class extends ValorantApiError {
+  constructor(status, endpoint2, url, body, headers, retryAfterMs) {
+    super(status, endpoint2, url, body, headers);
+    this.retryAfterMs = retryAfterMs;
+  }
+  retryAfterMs;
+};
+function extractErrorCode(body) {
+  if (typeof body === "object" && body !== null && "errorCode" in body) {
+    const code = body.errorCode;
+    return typeof code === "string" ? code : void 0;
+  }
+  return void 0;
+}
+
+// src/auth.ts
+function parseAuthRedirect(location) {
+  const fragment = location.split("#")[1];
+  if (fragment === void 0) return void 0;
+  const params = new URLSearchParams(fragment);
+  const accessToken = params.get("access_token");
+  const idToken = params.get("id_token");
+  if (accessToken === null || idToken === null) return void 0;
+  const expiresIn = Number(params.get("expires_in"));
+  return { accessToken, idToken, expiresIn: Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn : void 0 };
+}
+var AUTH_COOKIES_BODY = {
+  client_id: "play-valorant-web-prod",
+  nonce: "1",
+  redirect_uri: "https://playvalorant.com/opt_in",
+  response_type: "token id_token",
+  scope: "account openid"
+};
+function createAuthFlows(client) {
+  const ctx = client.context;
+  function applyTokens(tokens) {
+    if (tokens) ctx.update({ accessToken: tokens.accessToken, idToken: tokens.idToken });
+  }
+  function toLoginResult(data) {
+    const body = data ?? {};
+    if (body.type === "multifactor") return { status: "multifactor", email: body.multifactor?.email ?? "" };
+    const redirect = body.success?.redirect_url ?? JSON.stringify(data);
+    const tokens = parseAuthRedirect(redirect.replaceAll("\\u0026", "&"));
+    applyTokens(tokens);
+    return { status: "success", tokens };
+  }
+  return {
+    async login(options) {
+      await client.auth.cookies({ body: AUTH_COOKIES_BODY });
+      const data = await client.auth.request({
+        body: {
+          type: "auth",
+          language: "en_US",
+          remember: options.remember ?? true,
+          riot_identity: { captcha: options.captcha, username: options.username, password: options.password }
+        }
+      });
+      return toLoginResult(data);
+    },
+    async submitMfa(code, rememberDevice = true) {
+      const data = await client.auth.multiFactor({ body: { type: "multifactor", multifactor: { otp: code, rememberDevice } } });
+      return toLoginResult(data);
+    },
+    async reauthenticate(options) {
+      const response = await client.send(import_valorant_api_types2.endpoints.cookieReauthEndpoint);
+      const tokens = parseAuthRedirect(response.headers.get("location") ?? "");
+      if (tokens === void 0) throw new ValorantError("Cookie reauthentication failed: the session cookies are missing or expired, log in again");
+      applyTokens(tokens);
+      await this.establishSession(options);
+      return tokens;
+    },
+    async establishSession(options) {
+      const { entitlements_token } = await client.auth.entitlement();
+      ctx.set("entitlementToken", entitlements_token);
+      const info = await client.auth.playerInfo();
+      ctx.set("puuid", info.sub);
+      const geo = await client.auth.riotGeo({ body: { id_token: ctx.require("idToken") } });
+      ctx.applyAffinity(geo.affinities.live);
+      if (options?.fetchClientVersion) await this.fetchClientVersion();
+    },
+    async fetchClientVersion() {
+      const response = await client.transport({
+        method: "GET",
+        url: "https://valorant-api.com/v1/version",
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(15e3)
+      });
+      const version = JSON.parse(response.text).data?.riotClientVersion;
+      if (!version) throw new ValorantError("valorant-api.com did not return a client version");
+      ctx.set("clientVersion", version);
+      return version;
+    }
+  };
+}
+
+// src/context.ts
+var DEFAULT_PLATFORM = btoa(JSON.stringify({
+  platformType: "PC",
+  platformOS: "Windows",
+  platformOSVersion: "10.0.19042.1.256.64bit",
+  platformChipset: "Unknown"
+}));
+var SECRET_KEYS = ["accessToken", "entitlementToken", "idToken", "pasToken", "cookies", "localPassword"];
+var REGION_TO_SHARD = { na: "na", latam: "na", br: "na", eu: "eu", ap: "ap", kr: "kr" };
+function isRegion(value) {
+  return Object.hasOwn(REGION_TO_SHARD, value);
+}
+function shardForRegion(region) {
+  return REGION_TO_SHARD[region];
+}
+var ValorantContext = class {
+  #state;
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(initial = {}) {
+    this.#state = Object.freeze({ clientPlatform: DEFAULT_PLATFORM, ...stripUndefined(initial) });
+  }
+  get(key) {
+    return this.#state[key];
+  }
+  /** Like {@link get}, but throws {@link MissingContextError} when the value is not set. */
+  require(key) {
+    const value = this.#state[key];
+    if (value === void 0) throw new MissingContextError(key);
+    return value;
+  }
+  has(key) {
+    return this.#state[key] !== void 0;
+  }
+  /** Sets one value. `undefined` removes it. */
+  set(key, value) {
+    this.update({ [key]: value });
+  }
+  /** Merges a patch into the state. Keys set to `undefined` are removed. */
+  update(patch) {
+    this.#commit({ ...this.#state, ...patch });
+  }
+  /** Replaces the whole state. The default client platform is kept unless provided. */
+  replace(next) {
+    this.#commit({ clientPlatform: DEFAULT_PLATFORM, ...next });
+  }
+  /** Removes everything except the default client platform. */
+  clear() {
+    this.replace({});
+  }
+  /** Sets region and the matching shard from a Riot affinity (`eu`, `latam`, ...). Unknown values are ignored. */
+  applyAffinity(affinity) {
+    if (!isRegion(affinity)) return false;
+    this.update({ region: affinity, shard: shardForRegion(affinity) });
+    return true;
+  }
+  setCookie(name, value) {
+    const cookies = { ...this.#state.cookies };
+    if (value === void 0) delete cookies[name];
+    else cookies[name] = value;
+    this.update({ cookies });
+  }
+  cookieHeader() {
+    const entries = Object.entries(this.#state.cookies ?? {});
+    return entries.length === 0 ? void 0 : entries.map(([name, value]) => `${name}=${value}`).join("; ");
+  }
+  /** Immutable copy of the current state. Contains secrets. */
+  snapshot() {
+    return this.#state;
+  }
+  /** Calls `listener` after every change. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => void this.#listeners.delete(listener);
+  }
+  /** State with secrets masked, safe to log. */
+  redacted() {
+    const out = { ...this.#state };
+    for (const key of SECRET_KEYS) {
+      if (out[key] !== void 0) out[key] = "[redacted]";
+    }
+    return out;
+  }
+  toJSON() {
+    return this.redacted();
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.redacted();
+  }
+  #commit(next) {
+    const previous = this.#state;
+    const clean = Object.freeze(stripUndefined(next));
+    const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(clean)]);
+    const changed = [...keys].filter((key) => !sameValue(previous[key], clean[key]));
+    if (changed.length === 0) return;
+    this.#state = clean;
+    for (const listener of [...this.#listeners]) listener(clean, changed);
+  }
+};
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+function sameValue(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const aEntries = Object.entries(a);
+  const bEntries = Object.entries(b);
+  return aEntries.length === bEntries.length && aEntries.every(([key, value]) => Object.is(b[key], value));
+}
+
+// src/http.ts
+var fetchTransport = async (request) => {
+  const response = await fetch(request.url, {
+    method: request.method,
+    headers: request.headers,
+    body: request.body,
+    signal: request.signal,
+    redirect: "manual"
+  });
+  return {
+    status: response.status,
+    headers: response.headers,
+    setCookies: response.headers.getSetCookie(),
+    text: await response.text()
+  };
+};
+var localTransport = async (request) => {
+  const { request: httpsRequest } = await import("https");
+  const url = new URL(request.url);
+  if (url.hostname !== "127.0.0.1" && url.hostname !== "localhost") {
+    throw new Error(`localTransport only talks to loopback hosts, got ${url.hostname}`);
+  }
+  return new Promise((resolve, reject) => {
+    const req = httpsRequest(url, {
+      method: request.method,
+      headers: request.headers,
+      rejectUnauthorized: false,
+      signal: request.signal
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("error", reject);
+      res.on("end", () => {
+        const headers = new Headers();
+        for (const [name, value] of Object.entries(res.headers)) {
+          if (Array.isArray(value)) value.forEach((v) => headers.append(name, v));
+          else if (value !== void 0) headers.set(name, value);
+        }
+        resolve({
+          status: res.statusCode ?? 0,
+          headers,
+          setCookies: res.headers["set-cookie"] ?? [],
+          text: Buffer.concat(chunks).toString("utf8")
+        });
+      });
+    });
+    req.on("error", reject);
+    req.end(request.body);
+  });
+};
+
+// src/local.ts
+function parseLockfile(content) {
+  const [name, pid, port, password, protocol] = content.trim().split(":");
+  if (!name || !pid || !port || !password || !protocol) throw new ValorantError("Malformed lockfile");
+  return { name, pid: Number(pid), port: Number(port), password, protocol };
+}
+async function readLockfile(path) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const file = path ?? join(process.env["LOCALAPPDATA"] ?? "", "Riot Games", "Riot Client", "Config", "lockfile");
+  try {
+    return parseLockfile(await readFile(file, "utf8"));
+  } catch (cause) {
+    throw new ValorantError(`Could not read the Riot Client lockfile at "${file}". Is the Riot Client running?`, { cause });
+  }
+}
+function createLocalFlows(client) {
+  const ctx = client.context;
+  return {
+    async connect(options) {
+      const lockfile = await readLockfile(options?.lockfilePath);
+      ctx.update({ localPort: lockfile.port, localPassword: lockfile.password });
+      const tokens = await client.local.entitlementsToken();
+      ctx.update({ accessToken: tokens.accessToken, entitlementToken: tokens.token, puuid: tokens.subject });
+      const sessions = await client.local.sessions();
+      const valorant = Object.values(sessions).find((session) => session.productId === "valorant");
+      if (valorant) {
+        ctx.set("clientVersion", valorant.version);
+        const region = launchArgument(valorant.launchConfiguration.arguments, "ares-deployment");
+        if (region !== void 0 && isRegion(region)) ctx.update({ region, shard: shardForRegion(region) });
+      }
+      if (!ctx.has("region")) {
+        const info = await client.auth.playerInfo();
+        const affinity = Object.values(info.affinity ?? {}).find(isRegion);
+        if (affinity !== void 0) ctx.applyAffinity(affinity);
+      }
+      if (!ctx.has("clientVersion") && options?.fetchClientVersion !== false) {
+        await client.auth.fetchClientVersion().catch(() => void 0);
+      }
+    },
+    async events() {
+      return openEventStream(ctx);
+    }
+  };
+}
+function launchArgument(args, name) {
+  const prefix = `-${name}=`;
+  return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+async function openEventStream(ctx) {
+  let WebSocket;
+  try {
+    WebSocket = (await import("ws")).WebSocket;
+  } catch (cause) {
+    throw new ValorantError('The local event stream needs the optional "ws" package: npm install ws', { cause });
+  }
+  const socket = new WebSocket(`wss://127.0.0.1:${ctx.require("localPort")}`, {
+    headers: { Authorization: `Basic ${btoa(`riot:${ctx.require("localPassword")}`)}` },
+    rejectUnauthorized: false
+  });
+  const listeners = /* @__PURE__ */ new Set();
+  socket.on("message", (raw) => {
+    const text2 = raw.toString();
+    if (text2 === "") return;
+    const message = JSON.parse(text2);
+    if (!Array.isArray(message) || message[0] !== 8) return;
+    for (const listener of [...listeners]) listener(String(message[1]), message[2]);
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("open", resolve);
+    socket.once("error", reject);
+  });
+  return {
+    onEvent(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    subscribe: (eventName) => socket.send(JSON.stringify([5, eventName])),
+    unsubscribe: (eventName) => socket.send(JSON.stringify([6, eventName])),
+    close: () => socket.close()
+  };
+}
+
+// src/request.ts
+var import_valorant_api_types3 = require("valorant-api-types");
+
+// src/types.ts
+function paramName(variable) {
+  const [first = "", ...rest] = variable.replaceAll("-", " ").split(" ");
+  return first.charAt(0).toLowerCase() + first.slice(1) + rest.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+
+// src/request.ts
+var AUTH_HOST = "auth.riotgames.com";
+function applyQuirks(path, ctx) {
+  const hardcoded = "/leaderboards/affinity/na/";
+  return path.includes(hardcoded) ? path.replace(hardcoded, `/leaderboards/affinity/${ctx.require("shard")}/`) : path;
+}
+function resolvePath(endpoint2, input, ctx) {
+  const suffix = applyQuirks(endpoint2.suffix, ctx);
+  return suffix.replace(/\{([^}]+)\}/g, (_, variable) => {
+    const name = paramName(variable);
+    const value = input.params?.[name] ?? (name === "puuid" || name === "region" ? ctx.require(name) : void 0);
+    if (value === void 0) throw new MissingParameterError(name, endpoint2.name);
+    return encodeURIComponent(value);
+  });
+}
+function resolveBase(endpoint2, ctx) {
+  switch (endpoint2.type) {
+    case "pd":
+    case "shared":
+      return (0, import_valorant_api_types3.typeToPrefix)({ type: endpoint2.type, shard: ctx.require("shard") });
+    case "glz":
+      return (0, import_valorant_api_types3.typeToPrefix)({ type: "glz", shard: ctx.require("shard"), region: ctx.require("region") });
+    case "local":
+      return (0, import_valorant_api_types3.typeToPrefix)({ type: "local", port: ctx.require("localPort") });
+    case "other":
+      return "";
+  }
+}
+function appendQuery(url, query2) {
+  if (!query2) return url;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query2)) {
+    if (value !== void 0 && value !== null) params.append(key, String(value));
+  }
+  const encoded = params.toString();
+  if (encoded === "") return url;
+  return url + (url.includes("?") ? "&" : "?") + encoded;
+}
+function resolveHeaders(endpoint2, input, ctx, url) {
+  const headers = { Accept: "application/json" };
+  const need = endpoint2.riotRequirements ?? {};
+  const userAgent = ctx.get("userAgent");
+  if (userAgent) headers["User-Agent"] = userAgent;
+  if (need.token) headers["Authorization"] = `Bearer ${ctx.require("accessToken")}`;
+  if (need.localAuth) headers["Authorization"] = `Basic ${btoa(`riot:${ctx.require("localPassword")}`)}`;
+  if (need.entitlement) headers["X-Riot-Entitlements-JWT"] = ctx.require("entitlementToken");
+  if (need.clientVersion) headers["X-Riot-ClientVersion"] = ctx.require("clientVersion");
+  if (need.clientPlatform) headers["X-Riot-ClientPlatform"] = ctx.require("clientPlatform");
+  for (const [name, value] of endpoint2.headers ?? []) headers[name] = value;
+  if (input.body !== void 0 && !Object.keys(headers).some((h) => h.toLowerCase() === "content-type")) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (new URL(url).hostname === AUTH_HOST) {
+    const cookie = ctx.cookieHeader();
+    if (cookie) headers["Cookie"] = cookie;
+  }
+  return { ...headers, ...input.headers };
+}
+function isAuthHost(url) {
+  return new URL(url).hostname === AUTH_HOST;
+}
+function buildRequest(endpoint2, input, ctx) {
+  const path = resolvePath(endpoint2, input, ctx);
+  const base = resolveBase(endpoint2, ctx);
+  const url = appendQuery(base + (base === "" ? path : path.replace(/^\/+/, "")), input.query);
+  const method = endpoint2.method ?? "GET";
+  const headers = resolveHeaders(endpoint2, input, ctx, url);
+  const declaresJson = [...endpoint2.headers?.keys() ?? []].some((h) => h.toLowerCase() === "content-type");
+  const body = input.body !== void 0 ? JSON.stringify(input.body) : method !== "GET" && declaresJson ? "{}" : void 0;
+  return { method, url, headers, body };
+}
+
+// src/client.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE"]);
+var ValorantClient = class {
+  context;
+  #options;
+  #warned = /* @__PURE__ */ new Set();
+  #refreshing;
+  constructor(options = {}) {
+    this.#options = options;
+    this.context = options.context instanceof ValorantContext ? options.context : new ValorantContext(options.context);
+    Object.assign(this, this.#createApi());
+  }
+  /** Sends a request and returns status, headers and the parsed body. */
+  async send(endpoint2, options = {}) {
+    const input = options;
+    const validation = input.validation ?? this.#options.validation ?? "loose";
+    if (validation === "strict" && endpoint2.body !== void 0 && input.body !== void 0) {
+      const parsed = endpoint2.body.safeParse(input.body);
+      if (!parsed.success) throw new ValorantValidationError("request", endpoint2.name, parsed.error, input.body);
+    }
+    const retry = this.#options.retry === false ? void 0 : this.#options.retry ?? {};
+    const maxRetries = retry ? retry.retries ?? 2 : 0;
+    let refreshed = false;
+    for (let attempt = 0; ; attempt++) {
+      const request = buildRequest(endpoint2, input, this.context);
+      const canRetry = attempt < maxRetries && input.signal?.aborted !== true;
+      let response;
+      try {
+        response = await this.#transportFor(endpoint2)({ ...request, signal: this.#signal(input) });
+      } catch (cause) {
+        if (canRetry && IDEMPOTENT.has(request.method) && input.signal?.aborted !== true) {
+          await sleep(backoff(attempt, retry), input.signal);
+          continue;
+        }
+        throw new ValorantNetworkError(`${endpoint2.name} could not reach ${new URL(request.url).host}`, request.url, { cause });
+      }
+      if (isAuthHost(request.url)) this.#storeCookies(response.setCookies);
+      this.#options.logger?.debug?.(`${request.method} ${request.url} -> ${response.status}`);
+      if (response.status < 400) {
+        return {
+          status: response.status,
+          headers: response.headers,
+          data: this.#parseResponse(endpoint2, response, validation)
+        };
+      }
+      const error = this.#toError(endpoint2, request, response);
+      if (error instanceof ValorantAuthError && this.#options.refreshTokens && !refreshed) {
+        refreshed = true;
+        await this.#refreshOnce();
+        continue;
+      }
+      if (canRetry && RETRYABLE_STATUS.has(response.status) && (response.status === 429 || IDEMPOTENT.has(request.method))) {
+        const retryAfter = error instanceof ValorantRateLimitError ? error.retryAfterMs : void 0;
+        await sleep(retryAfter ?? backoff(attempt, retry), input.signal);
+        continue;
+      }
+      throw error;
+    }
+  }
+  #createApi() {
+    const api = {};
+    for (const [group, endpoints] of Object.entries(registry)) {
+      api[group] = Object.fromEntries(Object.entries(endpoints).map(([name, endpoint2]) => [
+        name,
+        async (options) => (await this.send(endpoint2, options)).data
+      ]));
+    }
+    Object.assign(api["auth"], createAuthFlows(this));
+    Object.assign(api["local"], createLocalFlows(this));
+    return api;
+  }
+  #transportFor(endpoint2) {
+    if (endpoint2.type === "local") return this.#options.localTransport ?? localTransport;
+    return this.#options.transport ?? fetchTransport;
+  }
+  /** Transport used for requests to arbitrary remote hosts. */
+  get transport() {
+    return this.#options.transport ?? fetchTransport;
+  }
+  #signal(input) {
+    const timeout = AbortSignal.timeout(input.timeoutMs ?? this.#options.timeoutMs ?? 15e3);
+    return input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
+  }
+  #storeCookies(setCookies) {
+    for (const line of setCookies) {
+      const [pair = "", ...attributes] = line.split(";").map((part) => part.trim());
+      const separator = pair.indexOf("=");
+      if (separator <= 0) continue;
+      const name = pair.slice(0, separator);
+      const value = pair.slice(separator + 1);
+      const expired = value === "" || attributes.some((a) => a.toLowerCase() === "max-age=0");
+      this.context.setCookie(name, expired ? void 0 : value);
+    }
+  }
+  #parseResponse(endpoint2, response, validation) {
+    const data = unwrapEnvelope(endpoint2, parseBody(response.text));
+    const schema = endpoint2.responses?.[String(response.status)];
+    if (schema === void 0 || validation === "off") return data;
+    const parsed = safeParse(schema, data);
+    if (parsed.success) return parsed.data;
+    if (validation === "strict") throw new ValorantValidationError("response", endpoint2.name, parsed.error, data);
+    if (!this.#warned.has(endpoint2.name)) {
+      this.#warned.add(endpoint2.name);
+      this.#options.logger?.warn(`Response of "${endpoint2.name}" does not match its schema, returning raw data`, parsed.error.issues.slice(0, 5));
+    }
+    return data;
+  }
+  #toError(endpoint2, request, response) {
+    const body = parseBody(response.text);
+    const args = [response.status, endpoint2.name, request.url, body, response.headers];
+    if (response.status === 429) return new ValorantRateLimitError(...args, parseRetryAfter(response.headers.get("retry-after")));
+    const needsToken = endpoint2.riotRequirements?.token === true;
+    const badClaims = typeof body === "object" && body !== null && body.errorCode === "BAD_CLAIMS";
+    if (needsToken && (response.status === 401 || response.status === 400 && badClaims)) return new ValorantAuthError(...args);
+    return new ValorantApiError(...args);
+  }
+  #refreshOnce() {
+    this.#refreshing ??= Promise.resolve(this.#options.refreshTokens(this)).finally(() => {
+      this.#refreshing = void 0;
+    });
+    return this.#refreshing;
+  }
+};
+function safeParse(schema, data) {
+  try {
+    return schema.safeParse(data);
+  } catch (thrown) {
+    if (thrown instanceof import_zod4.ZodError) return { success: false, error: thrown };
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return { success: false, error: new import_zod4.ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
+  }
+}
+function parseBody(text2) {
+  if (text2 === "") return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function parseRetryAfter(value) {
+  if (value === null) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function backoff(attempt, retry) {
+  const base = retry?.baseDelayMs ?? 500;
+  const max = retry?.maxDelayMs ?? 8e3;
+  return Math.min(max, base * 2 ** attempt) * (0.5 + Math.random() / 2);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+  });
+}
+
+// src/index.ts
+__reExport(index_exports, require("valorant-api-types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MissingContextError,
+  MissingParameterError,
+  ValorantApiError,
+  ValorantAuthError,
+  ValorantClient,
+  ValorantContext,
+  ValorantError,
+  ValorantNetworkError,
+  ValorantRateLimitError,
+  ValorantValidationError,
+  fetchTransport,
+  isRegion,
+  localTransport,
+  parseAuthRedirect,
+  parseLockfile,
+  readLockfile,
+  registry,
+  shardForRegion,
+  ...require("valorant-api-types")
+});
+//# sourceMappingURL=index.cjs.map