@voxary/valorant-client 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -31,6 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Agent: () => Agent,
+  CustomGameMap: () => CustomGameMap,
+  CustomGameMode: () => CustomGameMode,
+  CustomGameTeam: () => CustomGameTeam,
+  MEMBERSHIP_KEY: () => MEMBERSHIP_KEY,
   MissingContextError: () => MissingContextError,
   MissingParameterError: () => MissingParameterError,
   ValorantApiError: () => ValorantApiError,
@@ -41,6 +46,9 @@ __export(index_exports, {
   ValorantNetworkError: () => ValorantNetworkError,
   ValorantRateLimitError: () => ValorantRateLimitError,
   ValorantValidationError: () => ValorantValidationError,
+  agentName: () => agentName,
+  customGameMapName: () => customGameMapName,
+  customGameModeName: () => customGameModeName,
   fetchTransport: () => fetchTransport,
   isRegion: () => isRegion,
   localTransport: () => localTransport,
@@ -48,778 +56,2427 @@ __export(index_exports, {
   parseLockfile: () => parseLockfile,
   readLockfile: () => readLockfile,
   registry: () => registry,
-  shardForRegion: () => shardForRegion
+  shardForRegion: () => shardForRegion,
+  teamOfPlayer: () => teamOfPlayer
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/client.ts
-var import_zod4 = require("zod");
+// src/api/groups/pvp.ts
+var import_valorant_api_types10 = require("valorant-api-types");
 
-// src/api/registry.ts
-var import_valorant_api_types = require("valorant-api-types");
-
-// src/extra/catalog.ts
+// src/endpoints/riot/account.ts
 var import_zod = require("zod");
 
-// src/envelope.ts
-var enveloped = /* @__PURE__ */ new WeakSet();
-function markEnveloped(endpoint2) {
-  enveloped.add(endpoint2);
-  return endpoint2;
+// src/endpoints/riot/shared.ts
+var player = { token: true, entitlement: true, clientVersion: true, clientPlatform: true };
+function withResponse(endpoint2, schema) {
+  return { ...endpoint2, responses: { "200": schema } };
 }
-function unwrapEnvelope(endpoint2, body) {
-  if (enveloped.has(endpoint2) && typeof body === "object" && body !== null && "data" in body) {
-    return body.data;
-  }
-  return body;
+function onSharedHost(endpoint2) {
+  return { ...endpoint2, type: "shared" };
 }
 
-// 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/endpoints/riot/account.ts
+var dailyTicketEndpoint = {
+  name: "Daily Ticket",
+  description: "Daily ticket rewards and the matches already counted.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "daily-ticket/v1/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    Version: import_zod.z.number(),
+    DailyRewards: import_zod.z.object({
+      RemainingLifetimeSeconds: import_zod.z.number(),
+      BonusMilestonesPending: import_zod.z.number(),
+      Milestones: import_zod.z.array(import_zod.z.object({
+        Progress: import_zod.z.number(),
+        BonusApplied: import_zod.z.boolean()
+      }))
+    }),
+    ProcessedMatches: import_zod.z.array(import_zod.z.object({
+      ID: import_zod.z.string(),
+      CreatedAt: import_zod.z.string(),
+      DailyExpireTime: import_zod.z.string(),
+      PreviousDailyExpireTime: import_zod.z.string(),
+      ProgressBefore: import_zod.z.number(),
+      ProgressAfter: import_zod.z.number(),
+      XP: import_zod.z.number(),
+      SoftCurrency: import_zod.z.number(),
+      WasPenalized: import_zod.z.boolean(),
+      BonusesApplied: import_zod.z.number(),
+      DailyBonusState: import_zod.z.array(import_zod.z.boolean())
+    }))
+  }) }
+};
+var dailyTicketQueueConfigEndpoint = {
+  name: "Daily Ticket Queue Config",
+  description: "Which queues count for the daily ticket.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "daily-ticket/v1/queue-config",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    default: import_zod.z.object({
+      flatProgressPerMatch: import_zod.z.number(),
+      progressPerRoundWin: import_zod.z.boolean()
+    }),
+    queueOverrides: import_zod.z.object({
+      abilitydraftarena: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      competitive: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_abilitydraftarena: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_competitive: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_dodgeball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_fortcollins: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_hurm: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_newmap: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_skirmish2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_skirmishascension1v1: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_skirmishascension2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_snowball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_spikerush: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_swiftplay: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_unrated: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_valaram: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      dodgeball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      fortcollins: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      ggteam: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      hurm: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      newmap: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      premier: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      skirmish2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      skirmishascension1v1: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      skirmishascension2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      snowball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      spikerush: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      swiftplay: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      unrated: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      valaram: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      })
+    })
+  }) }
+};
+var favoritesEndpoint = {
+  name: "Favorites",
+  description: "Favorited store content of the player.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "favorites/v1/players/{puuid}/favorites",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    Subject: import_zod.z.string(),
+    FavoritedContent: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+      FavoriteID: import_zod.z.string(),
+      ItemID: import_zod.z.string()
+    }))
+  }) }
+};
+var goldstarsEndpoint = {
+  name: "Goldstars",
+  description: "Goldstar definitions. Field names are obfuscated by the game.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "goldstars/v1/goldstars",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.array(import_zod.z.object({
+    id: import_zod.z.string(),
+    tempT: import_zod.z.number()
+  })) }
+};
+var goldstarsPlayerEndpoint = {
+  name: "Goldstars Player",
+  description: "Goldstars of a player. Field names are obfuscated by the game.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "goldstars/v1/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    puuid: import_zod.z.string(),
+    version: import_zod.z.number(),
+    tempS: import_zod.z.object({
+      "00000000-0000-0000-0000-000000000000": import_zod.z.object({
+        tempS: import_zod.z.string(),
+        tempA: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+          id: import_zod.z.string(),
+          tempC: import_zod.z.number(),
+          tempB: import_zod.z.number()
+        }))
+      }),
+      "8102cd81-43a0-d0d7-bd59-47b8fe9bed1b": import_zod.z.object({
+        tempS: import_zod.z.string(),
+        tempA: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+          id: import_zod.z.string(),
+          tempC: import_zod.z.number(),
+          tempB: import_zod.z.number()
+        }))
+      })
+    }),
+    tempM: import_zod.z.array(import_zod.z.object({
+      id: import_zod.z.string(),
+      tempG: import_zod.z.number(),
+      tempP: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+        tempA: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+          id: import_zod.z.string(),
+          tempV: import_zod.z.number(),
+          tempB: import_zod.z.boolean()
+        }))
+      }))
+    }))
+  }) }
+};
+var bloomlineQueuesEndpoint = {
+  name: "Bloomline Queues",
+  description: "Queues handled by the `bloomline` service. The purpose of the service is not documented.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "bloomline/v0/config/valid-queues",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    ProcessedQueues: import_zod.z.array(import_zod.z.string()),
+    PerformanceScoreQueues: import_zod.z.array(import_zod.z.string())
+  }) }
+};
+var bloomlinePlayerEndpoint = {
+  name: "Bloomline Player",
+  description: "Per-player data of the `bloomline` service. The purpose of the service is not documented.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "bloomline/v0/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    Subject: import_zod.z.string(),
+    Bonsais: import_zod.z.array(import_zod.z.object({
+      BonsaiID: import_zod.z.string(),
+      HypeID: import_zod.z.string().optional(),
+      BackgroundID: import_zod.z.string().optional(),
+      ClipID: import_zod.z.string().optional(),
+      BorderID: import_zod.z.string().optional(),
+      Flourish: import_zod.z.object({
+        ShortLevel: import_zod.z.number().optional(),
+        PreviousShortLevel: import_zod.z.number().optional(),
+        LongLevel: import_zod.z.number().optional(),
+        FlourishID: import_zod.z.string().optional(),
+        Points: import_zod.z.number().optional(),
+        PointsVersion: import_zod.z.number().optional()
+      }),
+      TrackProgressList: import_zod.z.array(import_zod.z.object({
+        TrackID: import_zod.z.string(),
+        TrackLevel: import_zod.z.number().optional()
+      }))
+    })),
+    LongGroupVersion: import_zod.z.number()
+  }) }
 };
 
-// src/extra/riot.ts
+// src/endpoints/riot/agentSelect.ts
+var import_valorant_api_types = require("valorant-api-types");
 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",
+var agentSelect = import_zod2.z.object({
+  ID: import_zod2.z.string(),
+  Version: import_zod2.z.number(),
+  Teams: import_zod2.z.array(import_zod2.z.object({
+    TeamID: import_zod2.z.string(),
+    TeamNumber: import_zod2.z.number(),
+    Players: import_zod2.z.array(import_zod2.z.object({
+      Subject: import_zod2.z.string(),
+      CharacterID: import_zod2.z.string(),
+      CharacterSelectionState: import_zod2.z.string(),
+      PregamePlayerState: import_zod2.z.string(),
+      CompetitiveTier: import_zod2.z.number(),
+      PlayerIdentity: import_zod2.z.object({
+        Subject: import_zod2.z.string(),
+        PlayerCardID: import_zod2.z.string(),
+        PlayerTitleID: import_zod2.z.string(),
+        AccountLevel: import_zod2.z.number(),
+        PreferredLevelBorderID: import_zod2.z.string(),
+        Incognito: import_zod2.z.boolean(),
+        HideAccountLevel: import_zod2.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod2.z.object({
+        SeasonID: import_zod2.z.string(),
+        NumberOfWins: import_zod2.z.number(),
+        Rank: import_zod2.z.number(),
+        LeaderboardRank: import_zod2.z.number()
+      }),
+      IsCaptain: import_zod2.z.boolean(),
+      PlatformType: import_zod2.z.string(),
+      PremierPrestige: import_zod2.z.object({})
+    }))
+  })),
+  AllyTeam: import_zod2.z.object({
+    TeamID: import_zod2.z.string(),
+    TeamNumber: import_zod2.z.number(),
+    Players: import_zod2.z.array(import_zod2.z.object({
+      Subject: import_zod2.z.string(),
+      CharacterID: import_zod2.z.string(),
+      CharacterSelectionState: import_zod2.z.string(),
+      PregamePlayerState: import_zod2.z.string(),
+      CompetitiveTier: import_zod2.z.number(),
+      PlayerIdentity: import_zod2.z.object({
+        Subject: import_zod2.z.string(),
+        PlayerCardID: import_zod2.z.string(),
+        PlayerTitleID: import_zod2.z.string(),
+        AccountLevel: import_zod2.z.number(),
+        PreferredLevelBorderID: import_zod2.z.string(),
+        Incognito: import_zod2.z.boolean(),
+        HideAccountLevel: import_zod2.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod2.z.object({
+        SeasonID: import_zod2.z.string(),
+        NumberOfWins: import_zod2.z.number(),
+        Rank: import_zod2.z.number(),
+        LeaderboardRank: import_zod2.z.number()
+      }),
+      IsCaptain: import_zod2.z.boolean(),
+      PlatformType: import_zod2.z.string(),
+      PremierPrestige: import_zod2.z.object({})
+    }))
+  }),
+  EnemyTeamSize: import_zod2.z.number(),
+  EnemyTeamLockCount: import_zod2.z.number(),
+  PregameState: import_zod2.z.string(),
+  LastUpdated: import_zod2.z.string(),
+  MapID: import_zod2.z.string(),
+  CastedVotes: import_zod2.z.object({}),
+  MapSelectStep: import_zod2.z.number(),
+  Team1: import_zod2.z.string(),
+  GamePodID: import_zod2.z.string(),
+  Mode: import_zod2.z.string(),
+  VoiceSessionID: import_zod2.z.string(),
+  MUCName: import_zod2.z.string(),
+  TeamMatchToken: import_zod2.z.string(),
+  QueueID: import_zod2.z.string(),
+  ProvisioningFlowID: import_zod2.z.string(),
+  IsRanked: import_zod2.z.boolean(),
+  PhaseTimeRemainingNS: import_zod2.z.number(),
+  StepTimeRemainingNS: import_zod2.z.number(),
+  altModesFlagADA: import_zod2.z.boolean(),
+  GameRules: import_zod2.z.object({
+    AccoladesEnabled: import_zod2.z.string(),
+    AllowGameModifiers: import_zod2.z.string(),
+    IsOvertimeWinByTwo: import_zod2.z.string(),
+    PlayOutAllRounds: import_zod2.z.string(),
+    ReplayRecordMatch: import_zod2.z.string(),
+    SkipMatchHistory: import_zod2.z.string(),
+    TournamentMode: import_zod2.z.string()
+  })
+});
+var selectCharacterEndpoint = withResponse(import_valorant_api_types.endpoints.selectCharacterEndpoint, agentSelect);
+var lockCharacterEndpoint = withResponse(import_valorant_api_types.endpoints.lockCharacterEndpoint, agentSelect);
+
+// src/endpoints/riot/chat.ts
+var import_valorant_api_types2 = require("valorant-api-types");
+var import_zod3 = require("zod");
+var chatSettingsEndpoint = {
+  name: "Settings",
+  description: "Get chat settings",
+  category: "Local Endpoints - Chat",
   type: "local",
-  suffix: "anti-addiction/v1/products/valorant/policies/shutdown/anti-addiction-state",
+  suffix: "chat/v1/settings",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod2.z.unknown() }
+  responses: { "200": import_zod3.z.object({
+    bounceDockIconEnabled: import_zod3.z.boolean(),
+    "chat-status-message": import_zod3.z.string(),
+    chatFilterDisabled: import_zod3.z.boolean(),
+    chatGBG: import_zod3.z.boolean(),
+    chatGroupDiscord: import_zod3.z.boolean(),
+    chatGroupMobile: import_zod3.z.boolean(),
+    chatGroupOffline: import_zod3.z.boolean(),
+    chatWindow: import_zod3.z.object({
+      detached: import_zod3.z.boolean(),
+      height: import_zod3.z.number(),
+      left: import_zod3.z.number(),
+      top: import_zod3.z.number(),
+      width: import_zod3.z.number()
+    }),
+    chatWindowDockedHeight: import_zod3.z.number(),
+    "closed-conversations": import_zod3.z.object({
+      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": import_zod3.z.number()
+    }),
+    friendRequestToastsDisabled: import_zod3.z.boolean(),
+    "hidden-conversations": import_zod3.z.object({}),
+    linkClickWarningEnabled: import_zod3.z.boolean(),
+    messageNotificationsEnabled: import_zod3.z.boolean(),
+    moreUnreadsEnabled: import_zod3.z.boolean(),
+    "muted-conversations": import_zod3.z.object({}),
+    recentlyPlayedFirstOpen: import_zod3.z.boolean(),
+    recentlyPlayedOpen: import_zod3.z.boolean(),
+    "roster-group-collapsed": import_zod3.z.object({}),
+    showWhenTypingEnabled: import_zod3.z.boolean(),
+    sortBy: import_zod3.z.string(),
+    usePlayerPreferences: import_zod3.z.boolean()
+  }) }
 };
-var localAntiAddictionWarningEndpoint = {
-  name: "Anti Addiction Warning",
-  description: "GET ANTI_ADDICTION_RNet_FetchWarningMessagePolicyState",
-  queryName: "ANTI_ADDICTION_RNet_FetchWarningMessagePolicyState",
-  category: "Local Endpoints",
+var chatTournamentInfoEndpoint = {
+  name: "Tournament Info",
+  description: "Get in-tournament conversations",
+  category: "Local Endpoints - Chat",
   type: "local",
-  suffix: "anti-addiction/v1/products/valorant/policies/warningMessage/anti-addiction-state",
+  suffix: "chat/v6/conversations/ares-tournaments",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod2.z.unknown() }
+  responses: { "200": import_zod3.z.object({}) }
 };
-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 chatParticipantsEndpoint = withResponse(import_valorant_api_types2.endpoints.chatParticipantsEndpoint, import_zod3.z.object({
+  participants: import_zod3.z.array(import_zod3.z.object({
+    activePlatform: import_zod3.z.string().nullable(),
+    cid: import_zod3.z.string(),
+    game_name: import_zod3.z.string(),
+    game_tag: import_zod3.z.string(),
+    isInteractionAllowed: import_zod3.z.boolean(),
+    muted: import_zod3.z.boolean(),
+    name: import_zod3.z.string(),
+    pid: import_zod3.z.string(),
+    puuid: import_zod3.z.string(),
+    region: import_zod3.z.string()
+  }))
+}));
+
+// src/endpoints/riot/contracts.ts
+var import_valorant_api_types3 = require("valorant-api-types");
+var import_zod4 = require("zod");
+var activeRecruitmentEventEndpoint = {
+  name: "Active Recruitment Event",
+  description: "The current agent recruitment event.",
+  category: "Contract Endpoints",
+  type: "pd",
+  suffix: "contracts/v1/agents/activeRecruitmentEvent",
+  riotRequirements: player,
+  responses: { "200": import_zod4.z.object({
+    AgentID: import_zod4.z.string(),
+    CounterID: import_zod4.z.string(),
+    MilestoneThreshold: import_zod4.z.number(),
+    StartDate: import_zod4.z.string(),
+    EndDate: import_zod4.z.string(),
+    IsActive: import_zod4.z.boolean(),
+    includedPlatforms: import_zod4.z.object({
+      console: import_zod4.z.object({
+        developmentOnly: import_zod4.z.boolean()
+      }),
+      mobile: import_zod4.z.object({
+        developmentOnly: import_zod4.z.boolean()
+      }),
+      pc: import_zod4.z.object({
+        developmentOnly: import_zod4.z.boolean()
+      })
+    })
+  }) }
 };
-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 contractsEndpoint = withResponse(import_valorant_api_types3.endpoints.contractsEndpoint, import_zod4.z.object({
+  Version: import_zod4.z.number(),
+  Subject: import_zod4.z.string(),
+  Contracts: import_zod4.z.array(import_zod4.z.object({
+    ContractDefinitionID: import_zod4.z.string(),
+    ContractProgression: import_zod4.z.object({
+      Version: import_zod4.z.number(),
+      TotalProgressionEarned: import_zod4.z.number()
+    }),
+    ProgressionLevelReached: import_zod4.z.number(),
+    ProgressionTowardsNextLevel: import_zod4.z.number()
+  })),
+  ActiveRecruitmentEventProgress: import_zod4.z.object({
+    AgentID: import_zod4.z.string(),
+    Version: import_zod4.z.number(),
+    CounterID: import_zod4.z.string(),
+    ProgressionEarned: import_zod4.z.number()
+  }),
+  Missions: import_zod4.z.array(import_zod4.z.object({
+    ID: import_zod4.z.string(),
+    Objectives: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number()),
+    Complete: import_zod4.z.boolean(),
+    ExpirationTime: import_zod4.z.string()
+  })),
+  MissionMetadata: import_zod4.z.object({
+    WeeklyCheckpoint: import_zod4.z.string(),
+    WeeklyRefillTime: import_zod4.z.string()
+  }),
+  BTEMilestone: import_zod4.z.number()
+}));
+
+// src/endpoints/riot/currentGame.ts
+var import_valorant_api_types4 = require("valorant-api-types");
+var import_zod5 = require("zod");
+var currentGameLoadoutsEndpoint = withResponse(import_valorant_api_types4.endpoints.currentGameLoadoutsEndpoint, import_zod5.z.object({
+  Loadouts: import_zod5.z.array(import_zod5.z.object({
+    CharacterID: import_zod5.z.string(),
+    Loadout: import_zod5.z.object({
+      Subject: import_zod5.z.string(),
+      Expressions: import_zod5.z.object({
+        AESSelections: import_zod5.z.array(import_zod5.z.object({
+          AssetID: import_zod5.z.string(),
+          TypeID: import_zod5.z.string()
+        }))
+      }),
+      DynamicOptions: import_zod5.z.object({}),
+      Items: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.object({
+        ID: import_zod5.z.string(),
+        TypeID: import_zod5.z.string(),
+        Sockets: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.object({
+          ID: import_zod5.z.string(),
+          Item: import_zod5.z.object({
+            ID: import_zod5.z.string(),
+            TypeID: import_zod5.z.string()
+          })
+        }))
+      }))
+    }),
+    Subject: import_zod5.z.string()
+  }))
+}));
+
+// src/endpoints/riot/esports.ts
+var import_zod6 = require("zod");
+var esportsLiveEventTimesEndpoint = {
+  name: "Esports Live Event Times",
+  description: "Live and upcoming esports matches, pick blocks and tournaments.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v2/liveEventTimes",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    Tournaments: import_zod6.z.array(import_zod6.z.object({
+      ID: import_zod6.z.string(),
+      StartTimeUTC: import_zod6.z.string(),
+      EndTimeUTC: import_zod6.z.string()
+    }))
+  }) }
 };
-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 esportsUpcomingMatchesEndpoint = {
+  name: "Esports Upcoming Matches",
+  description: "Upcoming esports matches.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v2/upcomingMatches",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({}) }
 };
-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 esportsPickemLeaguesEndpoint = {
+  name: "Esports Pickem Leagues",
+  description: "Pick'em leagues.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v1/pickem/leagues",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    PickemLeagues: import_zod6.z.array(import_zod6.z.object({
+      LeagueID: import_zod6.z.string(),
+      EldsLeagueID: import_zod6.z.string(),
+      Tournament: import_zod6.z.object({
+        ID: import_zod6.z.string(),
+        EldsTournamentID: import_zod6.z.string(),
+        LeagueID: import_zod6.z.string(),
+        PickBlocks: import_zod6.z.array(import_zod6.z.object({
+          ID: import_zod6.z.string(),
+          EldsTournamentID: import_zod6.z.string(),
+          Slug: import_zod6.z.object({
+            Slug: import_zod6.z.string()
+          }),
+          PickOpenTime: import_zod6.z.string(),
+          PickCloseTime: import_zod6.z.string(),
+          State: import_zod6.z.string(),
+          OpenLevel: import_zod6.z.string(),
+          BlockType: import_zod6.z.string(),
+          PickBlockElements: import_zod6.z.array(import_zod6.z.object({
+            ID: import_zod6.z.string(),
+            PickBlockID: import_zod6.z.string(),
+            Section: import_zod6.z.object({
+              ID: import_zod6.z.string(),
+              EldsSectionID: import_zod6.z.string(),
+              CorrectPick: import_zod6.z.object({
+                Entries: import_zod6.z.array(import_zod6.z.object({
+                  Index: import_zod6.z.number(),
+                  Correctness: import_zod6.z.string(),
+                  ParticipantID: import_zod6.z.string(),
+                  Points: import_zod6.z.number(),
+                  Rank: import_zod6.z.number()
+                })).nullable()
+              })
+            }),
+            Match: import_zod6.z.object({
+              ID: import_zod6.z.string(),
+              EldsMatchID: import_zod6.z.string(),
+              BaselinePoints: import_zod6.z.number(),
+              CorrectPick: import_zod6.z.string(),
+              ResultState: import_zod6.z.string()
+            }),
+            PickOpenTime: import_zod6.z.string(),
+            PickCloseTime: import_zod6.z.string(),
+            State: import_zod6.z.string(),
+            DisplayOrder: import_zod6.z.number()
+          })),
+          CompletionStatus: import_zod6.z.string()
+        })),
+        Participants: import_zod6.z.array(import_zod6.z.object({
+          ID: import_zod6.z.string(),
+          EldsTeamID: import_zod6.z.string()
+        }))
+      }),
+      Published: import_zod6.z.boolean()
+    }))
+  }) }
 };
+
+// src/endpoints/riot/local.ts
+var import_zod7 = require("zod");
 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() }
+  responses: { "200": import_zod7.z.string() }
 };
-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",
+var localAvailableLocalesEndpoint = {
+  name: "Available Locales",
+  description: "Get available locales",
   category: "Local Endpoints",
   type: "local",
-  suffix: "riotclient/command-line-args",
+  suffix: "rnet-product-registry/v4/available-product-locales/products/valorant/patchlines/live",
   riotRequirements: { localAuth: true },
-  responses: { "200": import_zod2.z.unknown() }
+  responses: { "200": import_zod7.z.array(import_zod7.z.string()) }
 };
 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() }
+  responses: { "200": import_zod7.z.string() }
 };
 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() }
+  responses: { "200": import_zod7.z.object({
+    clientId: import_zod7.z.string(),
+    expiry: import_zod7.z.number(),
+    scopes: import_zod7.z.array(import_zod7.z.string()),
+    token: import_zod7.z.string()
+  }) }
 };
 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() }
+  responses: { "200": import_zod7.z.object({
+    state: import_zod7.z.string()
+  }) }
 };
 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() }
+  responses: { "200": import_zod7.z.object({
+    state: import_zod7.z.string(),
+    token: import_zod7.z.string(),
+    tokenType: import_zod7.z.string()
+  }) }
 };
 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() }
+  responses: { "200": import_zod7.z.object({
+    pid: import_zod7.z.number(),
+    status: import_zod7.z.string()
+  }) }
 };
 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() }
+  responses: { "200": import_zod7.z.string() }
+};
+var localEulaEndpoint = {
+  name: "Eula",
+  description: "Get the EULA",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/agreement/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod7.z.string() }
+};
+var localPrivacyPolicyEndpoint = {
+  name: "Privacy Policy",
+  description: "Get privacy policy",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/privacy-policy/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod7.z.string() }
+};
+
+// src/endpoints/riot/party.ts
+var import_valorant_api_types5 = require("valorant-api-types");
+var import_zod8 = require("zod");
+var customGameTeam = import_zod8.z.array(import_zod8.z.object({ Subject: import_zod8.z.string().describe("PUUID") }));
+var customGameParty = import_zod8.z.object({
+  ID: import_zod8.z.string(),
+  MUCName: import_zod8.z.string(),
+  VoiceRoomID: import_zod8.z.string(),
+  Version: import_zod8.z.number(),
+  ClientVersion: import_zod8.z.string(),
+  Members: import_zod8.z.array(import_zod8.z.object({
+    Subject: import_zod8.z.string(),
+    CompetitiveTier: import_zod8.z.number(),
+    PlayerIdentity: import_zod8.z.object({
+      Subject: import_zod8.z.string(),
+      PlayerCardID: import_zod8.z.string(),
+      PlayerTitleID: import_zod8.z.string(),
+      AccountLevel: import_zod8.z.number(),
+      PreferredLevelBorderID: import_zod8.z.string(),
+      Incognito: import_zod8.z.boolean(),
+      HideAccountLevel: import_zod8.z.boolean()
+    }),
+    IsOwner: import_zod8.z.boolean(),
+    QueueEligibleRemainingAccountLevels: import_zod8.z.number(),
+    Pings: import_zod8.z.array(import_zod8.z.object({
+      Ping: import_zod8.z.number(),
+      GamePodID: import_zod8.z.string()
+    })),
+    IsReady: import_zod8.z.boolean(),
+    IsModerator: import_zod8.z.boolean(),
+    UseBroadcastHUD: import_zod8.z.boolean(),
+    PlatformType: import_zod8.z.string(),
+    PremierPrestige: import_zod8.z.object({}),
+    JoinedAt: import_zod8.z.string()
+  })),
+  State: import_zod8.z.string(),
+  PreviousState: import_zod8.z.string(),
+  StateTransitionReason: import_zod8.z.string(),
+  Accessibility: import_zod8.z.string(),
+  CustomGameData: import_zod8.z.object({
+    Settings: import_zod8.z.object({
+      Map: import_zod8.z.string(),
+      Mode: import_zod8.z.string(),
+      UseBots: import_zod8.z.boolean(),
+      GamePod: import_zod8.z.string(),
+      GameRules: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).nullable(),
+      EsportsCustomLobbyName: import_zod8.z.string()
+    }),
+    Membership: import_zod8.z.object({
+      teamOne: customGameTeam,
+      teamTwo: customGameTeam,
+      teamSpectate: customGameTeam,
+      teamOneCoaches: customGameTeam,
+      teamTwoCoaches: customGameTeam
+    }),
+    MaxPartySize: import_zod8.z.number(),
+    AutobalanceEnabled: import_zod8.z.boolean(),
+    AutobalanceMinPlayers: import_zod8.z.number(),
+    HasRecoveryData: import_zod8.z.boolean()
+  }),
+  MatchmakingData: import_zod8.z.object({
+    QueueID: import_zod8.z.string(),
+    PreferredGamePods: import_zod8.z.array(import_zod8.z.string()),
+    SkillDisparityRRPenalty: import_zod8.z.number(),
+    MaxPartySize: import_zod8.z.number()
+  }),
+  QueueEntryTime: import_zod8.z.string(),
+  EstimatedQueueTimeSeconds: import_zod8.z.number(),
+  ErrorNotification: import_zod8.z.object({
+    ErrorType: import_zod8.z.string()
+  }).optional(),
+  RestrictedSeconds: import_zod8.z.number(),
+  EligibleQueues: import_zod8.z.array(import_zod8.z.string()),
+  CheatData: import_zod8.z.object({
+    GamePodOverride: import_zod8.z.string(),
+    ForcePostGameProcessing: import_zod8.z.boolean()
+  }),
+  InviteCode: import_zod8.z.string()
+});
+var setCustomGameTeamEndpoint = {
+  name: "Set Custom Game Team",
+  description: "Moves a player to a team of the custom game. Only the party owner can move other players. `team` is `TeamOne` or `TeamTwo`. Resolves to the updated party, whose `CustomGameData.Membership` lists the players of each team.",
+  queryName: "Party_ChangeTeamInCustomGame",
+  category: "Party Endpoints",
+  type: "glz",
+  method: "POST",
+  suffix: "parties/v1/parties/{party id}/customgamemembership/{team}",
+  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
+  body: import_zod8.z.object({ playerToPutOnTeam: import_zod8.z.string().describe("PUUID of the player to move") }),
+  riotRequirements: player,
+  responses: { "200": customGameParty }
+};
+var customGamePartyEndpoint = {
+  name: "Custom Game Party",
+  description: "The party of a custom game lobby: members, teams (`CustomGameData.Membership`), map, mode and rules. Typed for custom game lobbies. `party.get` is the general version.",
+  queryName: "Party_FetchParty",
+  category: "Party Endpoints",
+  type: "glz",
+  suffix: "parties/v1/parties/{party id}",
+  riotRequirements: player,
+  responses: { "200": customGameParty }
+};
+var partyResponse = customGameParty.extend({ CustomGameData: customGameParty.shape.CustomGameData.optional() });
+var partyGenerateCodeEndpoint = withResponse(import_valorant_api_types5.endpoints.partyGenerateCodeEndpoint, customGameParty);
+var partyDisableCodeEndpoint = withResponse(import_valorant_api_types5.endpoints.partyDisableCodeEndpoint, customGameParty);
+var setPartyAccessibilityEndpoint = withResponse(import_valorant_api_types5.endpoints.setPartyAccessibilityEndpoint, customGameParty);
+var startCustomGameEndpoint = withResponse(import_valorant_api_types5.endpoints.startCustomGameEndpoint, customGameParty);
+var setCustomGameSettingsEndpoint = withResponse(import_valorant_api_types5.endpoints.setCustomGameSettingsEndpoint, customGameParty);
+var partyEndpoint = withResponse(import_valorant_api_types5.endpoints.partyEndpoint, partyResponse);
+var changeQueueEndpoint = withResponse(import_valorant_api_types5.endpoints.changeQueueEndpoint, partyResponse);
+var enterMatchmakingQueueEndpoint = withResponse(import_valorant_api_types5.endpoints.enterMatchmakingQueueEndpoint, partyResponse);
+var leaveMatchmakingQueueEndpoint = withResponse(import_valorant_api_types5.endpoints.leaveMatchmakingQueueEndpoint, partyResponse);
+var partyDeclineEndpoint = withResponse(import_valorant_api_types5.endpoints.partyDeclineEndpoint, partyResponse);
+var partyInviteEndpoint = withResponse(import_valorant_api_types5.endpoints.partyInviteEndpoint, partyResponse);
+var partySetMemberReadyEndpoint = withResponse(import_valorant_api_types5.endpoints.partySetMemberReadyEndpoint, partyResponse);
+var refreshCompetitiveTierEndpoint = withResponse(import_valorant_api_types5.endpoints.refreshCompetitiveTierEndpoint, partyResponse);
+var refreshPlayerIdentityEndpoint = withResponse(import_valorant_api_types5.endpoints.refreshPlayerIdentityEndpoint, partyResponse);
+var refreshPingsEndpoint = withResponse(import_valorant_api_types5.endpoints.refreshPingsEndpoint, partyResponse);
+
+// src/endpoints/riot/pregame.ts
+var import_valorant_api_types6 = require("valorant-api-types");
+var import_zod9 = require("zod");
+var pregameMatchEndpoint = withResponse(import_valorant_api_types6.endpoints.pregameMatchEndpoint, import_zod9.z.object({
+  ID: import_zod9.z.string(),
+  Version: import_zod9.z.number(),
+  Teams: import_zod9.z.array(import_zod9.z.object({
+    TeamID: import_zod9.z.string(),
+    TeamNumber: import_zod9.z.number(),
+    Players: import_zod9.z.array(import_zod9.z.object({
+      Subject: import_zod9.z.string(),
+      CharacterID: import_zod9.z.string(),
+      CharacterSelectionState: import_zod9.z.string(),
+      PregamePlayerState: import_zod9.z.string(),
+      CompetitiveTier: import_zod9.z.number(),
+      PlayerIdentity: import_zod9.z.object({
+        Subject: import_zod9.z.string(),
+        PlayerCardID: import_zod9.z.string(),
+        PlayerTitleID: import_zod9.z.string(),
+        AccountLevel: import_zod9.z.number(),
+        PreferredLevelBorderID: import_zod9.z.string(),
+        Incognito: import_zod9.z.boolean(),
+        HideAccountLevel: import_zod9.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod9.z.object({
+        SeasonID: import_zod9.z.string(),
+        NumberOfWins: import_zod9.z.number(),
+        Rank: import_zod9.z.number(),
+        LeaderboardRank: import_zod9.z.number()
+      }),
+      IsCaptain: import_zod9.z.boolean(),
+      PlatformType: import_zod9.z.string(),
+      PremierPrestige: import_zod9.z.object({})
+    }))
+  })),
+  AllyTeam: import_zod9.z.object({
+    TeamID: import_zod9.z.string(),
+    TeamNumber: import_zod9.z.number(),
+    Players: import_zod9.z.array(import_zod9.z.object({
+      Subject: import_zod9.z.string(),
+      CharacterID: import_zod9.z.string(),
+      CharacterSelectionState: import_zod9.z.string(),
+      PregamePlayerState: import_zod9.z.string(),
+      CompetitiveTier: import_zod9.z.number(),
+      PlayerIdentity: import_zod9.z.object({
+        Subject: import_zod9.z.string(),
+        PlayerCardID: import_zod9.z.string(),
+        PlayerTitleID: import_zod9.z.string(),
+        AccountLevel: import_zod9.z.number(),
+        PreferredLevelBorderID: import_zod9.z.string(),
+        Incognito: import_zod9.z.boolean(),
+        HideAccountLevel: import_zod9.z.boolean()
+      }),
+      SeasonalBadgeInfo: import_zod9.z.object({
+        SeasonID: import_zod9.z.string(),
+        NumberOfWins: import_zod9.z.number(),
+        Rank: import_zod9.z.number(),
+        LeaderboardRank: import_zod9.z.number()
+      }),
+      IsCaptain: import_zod9.z.boolean(),
+      PlatformType: import_zod9.z.string(),
+      PremierPrestige: import_zod9.z.object({})
+    }))
+  }),
+  EnemyTeamSize: import_zod9.z.number(),
+  EnemyTeamLockCount: import_zod9.z.number(),
+  PregameState: import_zod9.z.string(),
+  LastUpdated: import_zod9.z.string(),
+  MapID: import_zod9.z.string(),
+  CastedVotes: import_zod9.z.object({}),
+  MapSelectStep: import_zod9.z.number(),
+  Team1: import_zod9.z.string(),
+  GamePodID: import_zod9.z.string(),
+  Mode: import_zod9.z.string(),
+  VoiceSessionID: import_zod9.z.string(),
+  MUCName: import_zod9.z.string(),
+  TeamMatchToken: import_zod9.z.string(),
+  QueueID: import_zod9.z.string(),
+  ProvisioningFlowID: import_zod9.z.string(),
+  IsRanked: import_zod9.z.boolean(),
+  PhaseTimeRemainingNS: import_zod9.z.number(),
+  StepTimeRemainingNS: import_zod9.z.number(),
+  altModesFlagADA: import_zod9.z.boolean(),
+  /** Rules of the match by name. Only the rules the lobby set are present. */
+  GameRules: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string())
+}));
+var pregameLoadoutsEndpoint = withResponse(import_valorant_api_types6.endpoints.pregameLoadoutsEndpoint, import_zod9.z.object({
+  Loadouts: import_zod9.z.array(import_zod9.z.object({
+    Subject: import_zod9.z.string(),
+    Expressions: import_zod9.z.object({
+      AESSelections: import_zod9.z.array(import_zod9.z.object({
+        AssetID: import_zod9.z.string(),
+        TypeID: import_zod9.z.string()
+      }))
+    }),
+    DynamicOptions: import_zod9.z.object({}),
+    Items: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.object({
+      ID: import_zod9.z.string(),
+      TypeID: import_zod9.z.string(),
+      Sockets: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.object({
+        ID: import_zod9.z.string(),
+        Item: import_zod9.z.object({
+          ID: import_zod9.z.string(),
+          TypeID: import_zod9.z.string()
+        })
+      }))
+    }))
+  })),
+  LoadoutsValid: import_zod9.z.boolean()
+}));
+
+// src/endpoints/riot/premier.ts
+var import_zod10 = require("zod");
+var premierSeasonsEndpoint = {
+  name: "Premier Seasons",
+  description: "All Premier seasons of the shard. The affinity in the path is the region of the context.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/premier-seasons",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    PremierSeasons: import_zod10.z.array(import_zod10.z.object({
+      ID: import_zod10.z.string(),
+      Name: import_zod10.z.string(),
+      PreviousPremierSeasonID: import_zod10.z.string(),
+      NextPremierSeasonID: import_zod10.z.string(),
+      IsActive: import_zod10.z.boolean(),
+      StartTime: import_zod10.z.string(),
+      EndTime: import_zod10.z.string(),
+      Events: import_zod10.z.array(import_zod10.z.object({
+        ID: import_zod10.z.string(),
+        Type: import_zod10.z.string(),
+        StartDateTime: import_zod10.z.string(),
+        EndDateTime: import_zod10.z.string(),
+        MapSelectionStrategy: import_zod10.z.string(),
+        MapPoolMapIDs: import_zod10.z.array(import_zod10.z.string()),
+        PointsRequiredToParticipate: import_zod10.z.number()
+      })),
+      ScheduledEvents: import_zod10.z.array(import_zod10.z.object({
+        EventID: import_zod10.z.string(),
+        EventType: import_zod10.z.string(),
+        Conference: import_zod10.z.string(),
+        DivisionGroup: import_zod10.z.string(),
+        EventPresetName: import_zod10.z.string(),
+        StartDateTime: import_zod10.z.string(),
+        EndDateTime: import_zod10.z.string(),
+        TournamentRoundTimes: import_zod10.z.array(import_zod10.z.object({
+          StartDateTime: import_zod10.z.string(),
+          EndDateTime: import_zod10.z.string()
+        }))
+      })),
+      Conferences: import_zod10.z.array(import_zod10.z.object({
+        id: import_zod10.z.string(),
+        key: import_zod10.z.string(),
+        isSuper: import_zod10.z.boolean(),
+        gamePods: import_zod10.z.array(import_zod10.z.string()),
+        timezone: import_zod10.z.string(),
+        superConference: import_zod10.z.string().optional(),
+        leaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+        leaderboardPromotionFinalizationDateTime: import_zod10.z.string()
+      })),
+      Divisions: import_zod10.z.array(import_zod10.z.object({
+        Division: import_zod10.z.number(),
+        DivisionName: import_zod10.z.string(),
+        DivisionGroup: import_zod10.z.string(),
+        EventPresetName: import_zod10.z.string()
+      })),
+      DivisionThresholds: import_zod10.z.array(import_zod10.z.object({
+        playoffThresholdType: import_zod10.z.string(),
+        playoffThresholdValue: import_zod10.z.number(),
+        promotionThresholdType: import_zod10.z.string(),
+        promotionThresholdValue: import_zod10.z.number(),
+        shouldPromoteToSuperConference: import_zod10.z.boolean(),
+        skipReseedCriteria: import_zod10.z.string(),
+        conference: import_zod10.z.string().optional(),
+        division: import_zod10.z.number().optional(),
+        promotionConference: import_zod10.z.string().optional(),
+        skipReseedCriteriaValue: import_zod10.z.number().optional()
+      })),
+      EventPresets: import_zod10.z.object({
+        PRO: import_zod10.z.object({
+          EventPresetsByEventType: import_zod10.z.object({
+            LEAGUE: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
+              })
+            }),
+            SCRIM: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
+              })
+            }),
+            TOURNAMENT: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
+              })
+            })
+          })
+        }),
+        REGULAR: import_zod10.z.object({
+          EventPresetsByEventType: import_zod10.z.object({
+            LEAGUE: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
+              })
+            }),
+            SCRIM: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
+              })
+            }),
+            TOURNAMENT: import_zod10.z.object({
+              EventPresetName: import_zod10.z.string(),
+              eventType: import_zod10.z.string(),
+              bestOfN: import_zod10.z.number(),
+              matchmakingStrategy: import_zod10.z.string(),
+              queueID: import_zod10.z.string(),
+              pointsConfig: import_zod10.z.object({
+                PointsForWin: import_zod10.z.number(),
+                PointsForLoss: import_zod10.z.number()
+              })
+            })
+          })
+        })
+      }),
+      FlawlessPointRequirement: import_zod10.z.number(),
+      ChampionshipPointRequirement: import_zod10.z.number(),
+      ChampionshipEventID: import_zod10.z.string(),
+      EnrollmentPhaseStartDateTime: import_zod10.z.string(),
+      EnrollmentPhaseEndDateTime: import_zod10.z.string(),
+      LeaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+      LeaderboardPromotionFinalizationDateTime: import_zod10.z.string(),
+      LeaderboardFinalizationDateTime: import_zod10.z.string(),
+      ContenderEligibilityExpiryDateTime: import_zod10.z.string(),
+      StageLockTime: import_zod10.z.string(),
+      ParticipationRewardsActIDs: import_zod10.z.array(import_zod10.z.string()),
+      ParticipationRewards: import_zod10.z.object({
+        EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+          ItemTypeID: import_zod10.z.string(),
+          ItemID: import_zod10.z.string(),
+          Amount: import_zod10.z.number()
+        }))
+      }),
+      TournamentWinnerRewards: import_zod10.z.object({}),
+      DivisionWinnerRewards: import_zod10.z.object({
+        ADVANCED: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }))
+        }).optional(),
+        CONTENDER: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }))
+        }).optional(),
+        ELITE: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }))
+        }).optional(),
+        INTERMEDIATE: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }))
+        }).optional(),
+        OPEN: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }))
+        }).optional(),
+        INVITE: import_zod10.z.object({
+          EntitlementRewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }))
+        }).optional()
+      }),
+      RosterRecentActivityNumSeasons: import_zod10.z.number()
+    }))
+  }) }
+};
+var premierActiveSeasonEndpoint = {
+  name: "Premier Active Season",
+  description: "The Premier season that is running now.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/premier-seasons/active",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    ID: import_zod10.z.string(),
+    Name: import_zod10.z.string(),
+    PreviousPremierSeasonID: import_zod10.z.string(),
+    NextPremierSeasonID: import_zod10.z.string(),
+    IsActive: import_zod10.z.boolean(),
+    StartTime: import_zod10.z.string(),
+    EndTime: import_zod10.z.string(),
+    Events: import_zod10.z.array(import_zod10.z.object({
+      ID: import_zod10.z.string(),
+      Type: import_zod10.z.string(),
+      StartDateTime: import_zod10.z.string(),
+      EndDateTime: import_zod10.z.string(),
+      MapSelectionStrategy: import_zod10.z.string(),
+      MapPoolMapIDs: import_zod10.z.array(import_zod10.z.string()),
+      PointsRequiredToParticipate: import_zod10.z.number()
+    })),
+    ScheduledEvents: import_zod10.z.array(import_zod10.z.object({
+      EventID: import_zod10.z.string(),
+      EventType: import_zod10.z.string(),
+      Conference: import_zod10.z.string(),
+      DivisionGroup: import_zod10.z.string(),
+      EventPresetName: import_zod10.z.string(),
+      StartDateTime: import_zod10.z.string(),
+      EndDateTime: import_zod10.z.string(),
+      TournamentRoundTimes: import_zod10.z.array(import_zod10.z.object({
+        StartDateTime: import_zod10.z.string(),
+        EndDateTime: import_zod10.z.string()
+      }))
+    })),
+    Conferences: import_zod10.z.array(import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
+      isSuper: import_zod10.z.boolean(),
+      gamePods: import_zod10.z.array(import_zod10.z.string()),
+      timezone: import_zod10.z.string(),
+      superConference: import_zod10.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod10.z.string()
+    })),
+    Divisions: import_zod10.z.array(import_zod10.z.object({
+      Division: import_zod10.z.number(),
+      DivisionName: import_zod10.z.string(),
+      DivisionGroup: import_zod10.z.string(),
+      EventPresetName: import_zod10.z.string()
+    })),
+    DivisionThresholds: import_zod10.z.array(import_zod10.z.object({
+      playoffThresholdType: import_zod10.z.string(),
+      playoffThresholdValue: import_zod10.z.number(),
+      promotionThresholdType: import_zod10.z.string(),
+      promotionThresholdValue: import_zod10.z.number(),
+      shouldPromoteToSuperConference: import_zod10.z.boolean(),
+      skipReseedCriteria: import_zod10.z.string(),
+      conference: import_zod10.z.string().optional(),
+      division: import_zod10.z.number().optional(),
+      promotionConference: import_zod10.z.string().optional(),
+      skipReseedCriteriaValue: import_zod10.z.number().optional()
+    })),
+    EventPresets: import_zod10.z.object({
+      PRO: import_zod10.z.object({
+        EventPresetsByEventType: import_zod10.z.object({
+          LEAGUE: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
+            })
+          }),
+          SCRIM: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
+            })
+          }),
+          TOURNAMENT: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
+            })
+          })
+        })
+      }),
+      REGULAR: import_zod10.z.object({
+        EventPresetsByEventType: import_zod10.z.object({
+          LEAGUE: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
+            })
+          }),
+          SCRIM: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
+            })
+          }),
+          TOURNAMENT: import_zod10.z.object({
+            EventPresetName: import_zod10.z.string(),
+            eventType: import_zod10.z.string(),
+            bestOfN: import_zod10.z.number(),
+            matchmakingStrategy: import_zod10.z.string(),
+            queueID: import_zod10.z.string(),
+            pointsConfig: import_zod10.z.object({
+              PointsForWin: import_zod10.z.number(),
+              PointsForLoss: import_zod10.z.number()
+            })
+          })
+        })
+      })
+    }),
+    FlawlessPointRequirement: import_zod10.z.number(),
+    ChampionshipPointRequirement: import_zod10.z.number(),
+    ChampionshipEventID: import_zod10.z.string(),
+    EnrollmentPhaseStartDateTime: import_zod10.z.string(),
+    EnrollmentPhaseEndDateTime: import_zod10.z.string(),
+    LeaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+    LeaderboardPromotionFinalizationDateTime: import_zod10.z.string(),
+    LeaderboardFinalizationDateTime: import_zod10.z.string(),
+    ContenderEligibilityExpiryDateTime: import_zod10.z.string(),
+    StageLockTime: import_zod10.z.string(),
+    ParticipationRewards: import_zod10.z.object({}),
+    TournamentWinnerRewards: import_zod10.z.object({}),
+    DivisionWinnerRewards: import_zod10.z.object({}),
+    RosterRecentActivityNumSeasons: import_zod10.z.number()
+  }) }
+};
+var premierConferencesEndpoint = {
+  name: "Premier Conferences",
+  description: "Premier conferences of the region.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/conferences",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    PremierConferences: import_zod10.z.array(import_zod10.z.object({
+      id: import_zod10.z.string(),
+      key: import_zod10.z.string(),
+      isSuper: import_zod10.z.boolean(),
+      gamePods: import_zod10.z.array(import_zod10.z.string()),
+      timezone: import_zod10.z.string(),
+      superConference: import_zod10.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod10.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod10.z.string()
+    }))
+  }) }
+};
+var premierMatchLimitEndpoint = {
+  name: "Premier Match Limit",
+  description: "How many Premier matches can still be played and when the limit resets.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/matchlimitinfo",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    leagueMatchLimit: import_zod10.z.number(),
+    tournamentLimit: import_zod10.z.number(),
+    timeUntilNextResetSeconds: import_zod10.z.number()
+  }) }
+};
+var premierEligibilityEndpoint = {
+  name: "Premier Eligibility",
+  description: "Whether the player can join a Premier roster.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/player/eligibility",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    subject: import_zod10.z.string(),
+    accountVerificationStatus: import_zod10.z.boolean(),
+    rankedPlacementCompletionStatus: import_zod10.z.boolean(),
+    matchLimitReached: import_zod10.z.boolean(),
+    isOnProvidedRoster: import_zod10.z.boolean()
+  }) }
+};
+var premierPlayerV2Endpoint = {
+  name: "Premier Player V2",
+  description: "Premier membership of a player: roster id and pending invites.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v2/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    puuid: import_zod10.z.string(),
+    rosterId: import_zod10.z.string(),
+    version: import_zod10.z.number(),
+    createdAt: import_zod10.z.number(),
+    updatedAt: import_zod10.z.number()
+  }) }
+};
+var premierPlayerV3Endpoint = {
+  name: "Premier Player V3",
+  description: "Like v2, with prestige and contender eligibility.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v3/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    puuid: import_zod10.z.string(),
+    rosterId: import_zod10.z.string(),
+    prestige: import_zod10.z.object({
+      earnedPrestige: import_zod10.z.boolean(),
+      earnedAura: import_zod10.z.boolean(),
+      showTag: import_zod10.z.boolean(),
+      showPlating: import_zod10.z.boolean(),
+      showAura: import_zod10.z.boolean()
+    }),
+    contenderEligibilityExpiry: import_zod10.z.string(),
+    socialVersion: import_zod10.z.number(),
+    premierVersion: import_zod10.z.number(),
+    updatedAt: import_zod10.z.number(),
+    seasons: import_zod10.z.object({
+      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": import_zod10.z.object({
+        seasonId: import_zod10.z.string(),
+        hasEarnedPrestigeAura: import_zod10.z.boolean(),
+        hasEarnedParticipation: import_zod10.z.boolean(),
+        hasEarnedDivisionWinner: import_zod10.z.boolean()
+      }),
+      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": import_zod10.z.object({
+        seasonId: import_zod10.z.string(),
+        hasEarnedPrestigeAura: import_zod10.z.boolean(),
+        hasEarnedParticipation: import_zod10.z.boolean(),
+        hasEarnedDivisionWinner: import_zod10.z.boolean()
+      })
+    })
+  }) }
+};
+
+// src/endpoints/riot/presence.ts
+var import_valorant_api_types7 = require("valorant-api-types");
+var import_zod11 = require("zod");
+
+// src/internal/base64.ts
+function toBase64(text2) {
+  return Buffer.from(text2, "utf8").toString("base64");
+}
+function fromBase64(encoded) {
+  return Buffer.from(encoded, "base64").toString("utf8");
+}
+function basicAuth(user, password) {
+  return `Basic ${toBase64(`${user}:${password}`)}`;
+}
+
+// src/endpoints/riot/presence.ts
+var valorantPresence = import_zod11.z.object({
+  isIdle: import_zod11.z.boolean(),
+  isValid: import_zod11.z.boolean(),
+  matchPresenceData: import_zod11.z.object({
+    gameScoreType: import_zod11.z.string(),
+    matchMap: import_zod11.z.string(),
+    provisioningFlow: import_zod11.z.string(),
+    queueId: import_zod11.z.string(),
+    sessionLoopState: import_zod11.z.string()
+  }),
+  maxPartySize: import_zod11.z.number(),
+  partyId: import_zod11.z.string(),
+  partyOwnerMatchScoreAllyTeam: import_zod11.z.number(),
+  partyOwnerMatchScoreEnemyTeam: import_zod11.z.number(),
+  partyPresenceData: import_zod11.z.object({
+    customGameName: import_zod11.z.string(),
+    customGameTeam: import_zod11.z.string(),
+    isPartyCrossPlayEnabled: import_zod11.z.boolean(),
+    isPartyOwner: import_zod11.z.boolean(),
+    isPlayerCrossPlayEnabled: import_zod11.z.boolean(),
+    maxPartySize: import_zod11.z.number(),
+    partyAccessibility: import_zod11.z.string(),
+    partyClientVersion: import_zod11.z.string(),
+    partyId: import_zod11.z.string(),
+    partyLFM: import_zod11.z.boolean(),
+    partyOwnerMatchMap: import_zod11.z.string(),
+    partyOwnerMatchScoreAllyTeam: import_zod11.z.number(),
+    partyOwnerMatchScoreEnemyTeam: import_zod11.z.number(),
+    partyOwnerProvisioningFlow: import_zod11.z.string(),
+    partyOwnerSessionLoopState: import_zod11.z.string(),
+    partyPrecisePlatformTypes: import_zod11.z.number(),
+    partySize: import_zod11.z.number(),
+    partyState: import_zod11.z.string(),
+    partyVersion: import_zod11.z.number(),
+    queueEntryTime: import_zod11.z.string(),
+    rosterId: import_zod11.z.string(),
+    tournamentId: import_zod11.z.string()
+  }),
+  partySize: import_zod11.z.number(),
+  playerPresenceData: import_zod11.z.object({
+    accountLevel: import_zod11.z.number(),
+    competitiveTier: import_zod11.z.number(),
+    leaderboardPosition: import_zod11.z.number(),
+    platformOverride: import_zod11.z.string(),
+    playerCardId: import_zod11.z.string(),
+    playerTitleId: import_zod11.z.string(),
+    tempValueAA: import_zod11.z.number()
+  }),
+  premierPresenceData: import_zod11.z.object({
+    division: import_zod11.z.number(),
+    plating: import_zod11.z.number(),
+    rosterId: import_zod11.z.string(),
+    rosterName: import_zod11.z.string(),
+    rosterTag: import_zod11.z.string(),
+    rosterType: import_zod11.z.string(),
+    score: import_zod11.z.number(),
+    showAura: import_zod11.z.boolean(),
+    showPlating: import_zod11.z.boolean(),
+    showTag: import_zod11.z.boolean()
+  }),
+  provisioningFlow: import_zod11.z.string(),
+  queueId: import_zod11.z.string()
+});
+function decodePresence(raw) {
+  if (!raw) return null;
+  try {
+    return valorantPresence.parse(JSON.parse(fromBase64(raw)));
+  } catch {
+    return null;
+  }
+}
+var presenceEndpoint = withResponse(import_valorant_api_types7.endpoints.presenceEndpoint, import_zod11.z.object({
+  presences: import_zod11.z.array(import_zod11.z.object({
+    activePlatform: import_zod11.z.string().nullable(),
+    basic: import_zod11.z.string(),
+    game_name: import_zod11.z.string(),
+    game_tag: import_zod11.z.string(),
+    msg: import_zod11.z.string().nullable(),
+    name: import_zod11.z.string(),
+    packedData: import_zod11.z.string().nullable(),
+    patchline: import_zod11.z.string().nullable(),
+    pid: import_zod11.z.string(),
+    platform: import_zod11.z.string().nullable(),
+    product: import_zod11.z.string(),
+    puuid: import_zod11.z.string(),
+    region: import_zod11.z.string(),
+    resource: import_zod11.z.string(),
+    state: import_zod11.z.string(),
+    summary: import_zod11.z.string(),
+    time: import_zod11.z.number(),
+    private: import_zod11.z.string().nullable().transform(decodePresence)
+  }))
+}));
+
+// src/endpoints/riot/pvp.ts
+var import_valorant_api_types8 = require("valorant-api-types");
+var import_zod12 = require("zod");
+var playerLoadoutV3Endpoint = {
+  name: "Player Loadout V3",
+  description: "Current loadout. The v2 route used by `pvp.playerLoadout` answers 404 on current clients.",
+  category: "PVP Endpoints",
+  type: "pd",
+  suffix: "personalization/v3/players/{puuid}/playerloadout",
+  riotRequirements: player,
+  responses: { "200": import_zod12.z.object({
+    Subject: import_zod12.z.string(),
+    Version: import_zod12.z.number(),
+    Guns: import_zod12.z.array(import_zod12.z.object({
+      ID: import_zod12.z.string(),
+      SkinID: import_zod12.z.string(),
+      SkinLevelID: import_zod12.z.string(),
+      ChromaID: import_zod12.z.string(),
+      CharmInstanceID: import_zod12.z.string().optional(),
+      CharmID: import_zod12.z.string().optional(),
+      CharmLevelID: import_zod12.z.string().optional()
+    })),
+    ActiveExpressions: import_zod12.z.array(import_zod12.z.object({
+      TypeID: import_zod12.z.string(),
+      AssetID: import_zod12.z.string()
+    })),
+    DynamicOptions: import_zod12.z.object({}),
+    Identity: import_zod12.z.object({
+      PlayerCardID: import_zod12.z.string(),
+      PlayerTitleID: import_zod12.z.string(),
+      AccountLevel: import_zod12.z.number(),
+      PreferredLevelBorderID: import_zod12.z.string(),
+      HideAccountLevel: import_zod12.z.boolean()
+    }),
+    Incognito: import_zod12.z.boolean()
+  }) }
+};
+var configEndpoint = withResponse(
+  { ...onSharedHost(import_valorant_api_types8.endpoints.configEndpoint), riotRequirements: player },
+  import_zod12.z.object({
+    LastApplication: import_zod12.z.string().datetime({ offset: true }).transform((value) => new Date(value)),
+    /** Game settings by name. Every value is a string, and the set of names changes with each patch. */
+    Collapsed: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string())
+  })
+);
+
+// src/endpoints/riot/restrictions.ts
+var import_zod13 = require("zod");
+var avoidListEndpoint = {
+  name: "Avoid List",
+  description: "Players the account avoids in matchmaking.",
+  category: "Restriction Endpoints",
+  type: "pd",
+  suffix: "restrictions/v1/avoidList",
+  riotRequirements: player,
+  responses: { "200": import_zod13.z.object({
+    Subject: import_zod13.z.string()
+  }) }
+};
+var activeFutureInterventionsEndpoint = {
+  name: "Active Future Interventions",
+  description: "Upcoming or active restrictions of the account, by category.",
+  category: "Restriction Endpoints",
+  type: "pd",
+  suffix: "restrictions/v1/activeFutureInterventions",
+  riotRequirements: player,
+  responses: { "200": import_zod13.z.object({
+    Subject: import_zod13.z.string()
+  }) }
+};
+
+// src/endpoints/riot/store.ts
+var import_valorant_api_types9 = require("valorant-api-types");
+var import_zod14 = require("zod");
+var agentStoreEndpoint = {
+  name: "Agent Store",
+  description: "Agents offered in the store.",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/storefronts/agent",
+  riotRequirements: player,
+  responses: { "200": import_zod14.z.object({
+    AgentStore: import_zod14.z.object({
+      AgentStoreOffers: import_zod14.z.array(import_zod14.z.object({
+        AgentID: import_zod14.z.string(),
+        StoreOffers: import_zod14.z.array(import_zod14.z.object({
+          OfferID: import_zod14.z.string(),
+          IsDirectPurchase: import_zod14.z.boolean(),
+          StartDate: import_zod14.z.string(),
+          Cost: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()),
+          Rewards: import_zod14.z.array(import_zod14.z.object({
+            ItemTypeID: import_zod14.z.string(),
+            ItemID: import_zod14.z.string(),
+            Quantity: import_zod14.z.number()
+          }))
+        }))
+      })),
+      CurrentFeaturedAgent: import_zod14.z.string(),
+      NextFeaturedAgent: import_zod14.z.string()
+    })
+  }) }
+};
+var allEntitlementsEndpoint = {
+  name: "All Entitlements",
+  description: "Everything the player owns, grouped by item type. This is the call without an item type, which is the shape `store.ownedItems` describes.",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/entitlements/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod14.z.object({
+    EntitlementsByTypes: import_zod14.z.array(import_zod14.z.object({
+      ItemTypeID: import_zod14.z.string(),
+      Entitlements: import_zod14.z.array(import_zod14.z.object({
+        TypeID: import_zod14.z.string(),
+        ItemID: import_zod14.z.string(),
+        InstanceID: import_zod14.z.string().optional()
+      }))
+    }))
+  }) }
+};
+var ownedItemsEndpoint = withResponse(import_valorant_api_types9.endpoints.ownedItemsEndpoint, import_zod14.z.object({
+  ItemTypeID: import_zod14.z.string(),
+  Entitlements: import_zod14.z.array(import_zod14.z.object({
+    TypeID: import_zod14.z.string(),
+    ItemID: import_zod14.z.string()
+  }))
+}));
+
+// src/endpoints/riot/storefront.ts
+var import_zod15 = require("zod");
+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.",
+  category: "Store Endpoints",
+  type: "pd",
+  method: "POST",
+  suffix: "store/v3/storefront/{puuid}",
+  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
+  riotRequirements: player,
+  responses: { "200": import_zod15.z.object({
+    FeaturedBundle: import_zod15.z.object({
+      Bundle: import_zod15.z.object({
+        ID: import_zod15.z.string(),
+        DataAssetID: import_zod15.z.string(),
+        CurrencyID: import_zod15.z.string(),
+        Items: import_zod15.z.array(import_zod15.z.object({
+          Item: import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Amount: import_zod15.z.number()
+          }),
+          BasePrice: import_zod15.z.number(),
+          CurrencyID: import_zod15.z.string(),
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedPrice: import_zod15.z.number(),
+          IsPromoItem: import_zod15.z.boolean()
+        })),
+        ItemOffers: import_zod15.z.array(import_zod15.z.object({
+          BundleItemOfferID: import_zod15.z.string(),
+          Offer: import_zod15.z.object({
+            OfferID: import_zod15.z.string(),
+            IsDirectPurchase: import_zod15.z.boolean(),
+            StartDate: import_zod15.z.string(),
+            Cost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+            }),
+            Rewards: import_zod15.z.array(import_zod15.z.object({
+              ItemTypeID: import_zod15.z.string(),
+              ItemID: import_zod15.z.string(),
+              Quantity: import_zod15.z.number()
+            }))
+          }),
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedCost: import_zod15.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+          })
+        })),
+        TotalBaseCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+        }),
+        TotalDiscountedCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+        }),
+        TotalDiscountPercent: import_zod15.z.number(),
+        DurationRemainingInSeconds: import_zod15.z.number(),
+        WholesaleOnly: import_zod15.z.boolean(),
+        IsGiftable: import_zod15.z.number()
+      }),
+      Bundles: import_zod15.z.array(import_zod15.z.object({
+        ID: import_zod15.z.string(),
+        DataAssetID: import_zod15.z.string(),
+        CurrencyID: import_zod15.z.string(),
+        Items: import_zod15.z.array(import_zod15.z.object({
+          Item: import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Amount: import_zod15.z.number()
+          }),
+          BasePrice: import_zod15.z.number(),
+          CurrencyID: import_zod15.z.string(),
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedPrice: import_zod15.z.number(),
+          IsPromoItem: import_zod15.z.boolean()
+        })),
+        ItemOffers: import_zod15.z.array(import_zod15.z.object({
+          BundleItemOfferID: import_zod15.z.string(),
+          Offer: import_zod15.z.object({
+            OfferID: import_zod15.z.string(),
+            IsDirectPurchase: import_zod15.z.boolean(),
+            StartDate: import_zod15.z.string(),
+            Cost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+            }),
+            Rewards: import_zod15.z.array(import_zod15.z.object({
+              ItemTypeID: import_zod15.z.string(),
+              ItemID: import_zod15.z.string(),
+              Quantity: import_zod15.z.number()
+            }))
+          }),
+          DiscountPercent: import_zod15.z.number(),
+          DiscountedCost: import_zod15.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+          })
+        })),
+        TotalBaseCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+        }),
+        TotalDiscountedCost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+        }),
+        TotalDiscountPercent: import_zod15.z.number(),
+        DurationRemainingInSeconds: import_zod15.z.number(),
+        WholesaleOnly: import_zod15.z.boolean(),
+        IsGiftable: import_zod15.z.number()
+      })),
+      FeaturedTileEntries: import_zod15.z.array(import_zod15.z.object({
+        Type: import_zod15.z.number(),
+        Entry: import_zod15.z.object({
+          Bundle: import_zod15.z.object({
+            ID: import_zod15.z.string(),
+            DataAssetID: import_zod15.z.string(),
+            CurrencyID: import_zod15.z.string(),
+            Items: import_zod15.z.array(import_zod15.z.object({
+              Item: import_zod15.z.object({
+                ItemTypeID: import_zod15.z.string(),
+                ItemID: import_zod15.z.string(),
+                Amount: import_zod15.z.number()
+              }),
+              BasePrice: import_zod15.z.number(),
+              CurrencyID: import_zod15.z.string(),
+              DiscountPercent: import_zod15.z.number(),
+              DiscountedPrice: import_zod15.z.number(),
+              IsPromoItem: import_zod15.z.boolean()
+            })),
+            ItemOffers: import_zod15.z.array(import_zod15.z.object({
+              BundleItemOfferID: import_zod15.z.string(),
+              Offer: import_zod15.z.object({
+                OfferID: import_zod15.z.string(),
+                IsDirectPurchase: import_zod15.z.boolean(),
+                StartDate: import_zod15.z.string(),
+                Cost: import_zod15.z.object({
+                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+                }),
+                Rewards: import_zod15.z.array(import_zod15.z.object({
+                  ItemTypeID: import_zod15.z.string(),
+                  ItemID: import_zod15.z.string(),
+                  Quantity: import_zod15.z.number()
+                }))
+              }),
+              DiscountPercent: import_zod15.z.number(),
+              DiscountedCost: import_zod15.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+              })
+            })),
+            TotalBaseCost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+            }),
+            TotalDiscountedCost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+            }),
+            TotalDiscountPercent: import_zod15.z.number(),
+            DurationRemainingInSeconds: import_zod15.z.number(),
+            WholesaleOnly: import_zod15.z.boolean(),
+            IsGiftable: import_zod15.z.number()
+          })
+        })
+      })),
+      BundleRemainingDurationInSeconds: import_zod15.z.number()
+    }),
+    SkinsPanelLayout: import_zod15.z.object({
+      SingleItemOffers: import_zod15.z.array(import_zod15.z.string()),
+      SingleItemStoreOffers: import_zod15.z.array(import_zod15.z.object({
+        OfferID: import_zod15.z.string(),
+        IsDirectPurchase: import_zod15.z.boolean(),
+        StartDate: import_zod15.z.string(),
+        Cost: import_zod15.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+        }),
+        Rewards: import_zod15.z.array(import_zod15.z.object({
+          ItemTypeID: import_zod15.z.string(),
+          ItemID: import_zod15.z.string(),
+          Quantity: import_zod15.z.number()
+        }))
+      })),
+      SingleItemOffersRemainingDurationInSeconds: import_zod15.z.number()
+    }),
+    UpgradeCurrencyStore: import_zod15.z.object({
+      UpgradeCurrencyOffers: import_zod15.z.array(import_zod15.z.object({
+        OfferID: import_zod15.z.string(),
+        StorefrontItemID: import_zod15.z.string(),
+        Offer: import_zod15.z.object({
+          OfferID: import_zod15.z.string(),
+          IsDirectPurchase: import_zod15.z.boolean(),
+          StartDate: import_zod15.z.string(),
+          Cost: import_zod15.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+          }),
+          Rewards: import_zod15.z.array(import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Quantity: import_zod15.z.number()
+          }))
+        }),
+        DiscountedPercent: import_zod15.z.number()
+      }))
+    }),
+    AccessoryStore: import_zod15.z.object({
+      AccessoryStoreOffers: import_zod15.z.array(import_zod15.z.object({
+        Offer: import_zod15.z.object({
+          OfferID: import_zod15.z.string(),
+          IsDirectPurchase: import_zod15.z.boolean(),
+          StartDate: import_zod15.z.string(),
+          Cost: import_zod15.z.object({
+            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": import_zod15.z.number()
+          }),
+          Rewards: import_zod15.z.array(import_zod15.z.object({
+            ItemTypeID: import_zod15.z.string(),
+            ItemID: import_zod15.z.string(),
+            Quantity: import_zod15.z.number()
+          }))
+        }),
+        ContractID: import_zod15.z.string()
+      })),
+      AccessoryStoreRemainingDurationInSeconds: import_zod15.z.number(),
+      StorefrontID: import_zod15.z.string()
+    }),
+    PluginStores: import_zod15.z.array(import_zod15.z.object({
+      PluginID: import_zod15.z.string(),
+      PluginOffers: import_zod15.z.object({
+        StoreOffers: import_zod15.z.array(import_zod15.z.object({
+          PurchaseInformation: import_zod15.z.object({
+            DataAssetID: import_zod15.z.string(),
+            OfferID: import_zod15.z.string(),
+            OfferType: import_zod15.z.number(),
+            StartDate: import_zod15.z.string(),
+            PrimaryCurrencyID: import_zod15.z.string(),
+            Cost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+            }),
+            DiscountedCost: import_zod15.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+            }),
+            DiscountedPercentage: import_zod15.z.number(),
+            WholesaleOnly: import_zod15.z.boolean(),
+            IsGiftable: import_zod15.z.number()
+          }),
+          SubOffers: import_zod15.z.array(import_zod15.z.object({
+            PurchaseInformation: import_zod15.z.object({
+              DataAssetID: import_zod15.z.string(),
+              OfferID: import_zod15.z.string(),
+              OfferType: import_zod15.z.number(),
+              StartDate: import_zod15.z.string(),
+              PrimaryCurrencyID: import_zod15.z.string(),
+              Cost: import_zod15.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+              }),
+              DiscountedCost: import_zod15.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod15.z.number()
+              }),
+              DiscountedPercentage: import_zod15.z.number(),
+              Rewards: import_zod15.z.array(import_zod15.z.object({
+                ItemTypeID: import_zod15.z.string(),
+                ItemID: import_zod15.z.string(),
+                Quantity: import_zod15.z.number()
+              })),
+              WholesaleOnly: import_zod15.z.boolean(),
+              IsGiftable: import_zod15.z.number()
+            })
+          }))
+        })),
+        RemainingDurationInSeconds: import_zod15.z.number()
+      }),
+      StartDate: import_zod15.z.string()
+    }))
+  }) }
 };
+
+// src/endpoints/riot/voice.ts
+var import_zod16 = require("zod");
 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() }
+  responses: { "200": import_zod16.z.object({
+    fastEnergyMeter: import_zod16.z.number(),
+    isLoopbackEnabled: import_zod16.z.boolean(),
+    isMicActive: import_zod16.z.boolean(),
+    isSpeakerActive: import_zod16.z.boolean(),
+    micEnergy: import_zod16.z.number(),
+    micVolume: import_zod16.z.number(),
+    noiseFloorMeter: import_zod16.z.number(),
+    speakerEnergy: import_zod16.z.number(),
+    speakerVolume: import_zod16.z.number(),
+    speechThresholdMeter: import_zod16.z.number()
+  }) }
 };
 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() }
+  responses: { "200": import_zod16.z.array(import_zod16.z.object({
+    handle: import_zod16.z.string(),
+    is_current_device: import_zod16.z.boolean(),
+    is_default: import_zod16.z.boolean(),
+    is_effective_device: import_zod16.z.boolean(),
+    name: import_zod16.z.string()
+  })) }
 };
 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() }
+  responses: { "200": import_zod16.z.array(import_zod16.z.object({
+    handle: import_zod16.z.string(),
+    is_current_device: import_zod16.z.boolean(),
+    is_default: import_zod16.z.boolean(),
+    is_effective_device: import_zod16.z.boolean(),
+    name: import_zod16.z.string()
+  })) }
 };
-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() }
+
+// src/api/groups/pvp.ts
+var pvp = {
+  content: import_valorant_api_types10.endpoints.fetchContentEndpoint,
+  accountXp: import_valorant_api_types10.endpoints.accountXPEndpoint,
+  setPlayerLoadout: import_valorant_api_types10.endpoints.setPlayerLoadoutEndpoint,
+  playerMmr: import_valorant_api_types10.endpoints.playerMMREndpoint,
+  matchHistory: import_valorant_api_types10.endpoints.matchHistoryEndpoint,
+  matchDetails: import_valorant_api_types10.endpoints.matchDetailsEndpoint,
+  competitiveUpdates: import_valorant_api_types10.endpoints.competitiveUpdatesEndpoint,
+  leaderboard: import_valorant_api_types10.endpoints.leaderboardEndpoint,
+  penalties: import_valorant_api_types10.endpoints.penaltiesEndpoint,
+  config: configEndpoint,
+  nameService: import_valorant_api_types10.endpoints.nameServiceEndpoint,
+  playerLoadoutV3: playerLoadoutV3Endpoint
 };
-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() }
+
+// src/api/groups/party.ts
+var import_valorant_api_types11 = require("valorant-api-types");
+var party = {
+  get: partyEndpoint,
+  player: import_valorant_api_types11.endpoints.partyPlayerEndpoint,
+  removePlayer: import_valorant_api_types11.endpoints.partyRemovePlayerEndpoint,
+  setMemberReady: partySetMemberReadyEndpoint,
+  refreshCompetitiveTier: refreshCompetitiveTierEndpoint,
+  refreshPlayerIdentity: refreshPlayerIdentityEndpoint,
+  refreshPings: refreshPingsEndpoint,
+  changeQueue: changeQueueEndpoint,
+  startCustomGame: startCustomGameEndpoint,
+  enterMatchmakingQueue: enterMatchmakingQueueEndpoint,
+  leaveMatchmakingQueue: leaveMatchmakingQueueEndpoint,
+  setAccessibility: setPartyAccessibilityEndpoint,
+  setCustomGameSettings: setCustomGameSettingsEndpoint,
+  invite: partyInviteEndpoint,
+  requestToJoin: import_valorant_api_types11.endpoints.partyRequestEndpoint,
+  declineRequest: partyDeclineEndpoint,
+  customGameConfigs: import_valorant_api_types11.endpoints.customGameConfigsEndpoint,
+  disableCode: partyDisableCodeEndpoint,
+  generateCode: partyGenerateCodeEndpoint,
+  joinByCode: import_valorant_api_types11.endpoints.partyJoinByCodeEndpoint,
+  setCustomGameTeam: setCustomGameTeamEndpoint,
+  getCustomGame: customGamePartyEndpoint
 };
-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/api/groups/store.ts
+var import_valorant_api_types12 = require("valorant-api-types");
+var store = {
+  wallet: import_valorant_api_types12.endpoints.walletEndpoint,
+  ownedItems: ownedItemsEndpoint,
+  storefrontV3: storefrontV3Endpoint,
+  agentStore: agentStoreEndpoint,
+  allEntitlements: allEntitlementsEndpoint
 };
 
-// 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())
+// src/api/groups/pregame.ts
+var import_valorant_api_types13 = require("valorant-api-types");
+var pregame = {
+  player: import_valorant_api_types13.endpoints.pregamePlayerEndpoint,
+  match: pregameMatchEndpoint,
+  loadouts: pregameLoadoutsEndpoint,
+  selectCharacter: selectCharacterEndpoint,
+  lockCharacter: lockCharacterEndpoint,
+  quit: import_valorant_api_types13.endpoints.pregameQuitEndpoint
+};
+
+// src/api/groups/currentGame.ts
+var import_valorant_api_types14 = require("valorant-api-types");
+var currentGame = {
+  player: import_valorant_api_types14.endpoints.currentGamePlayerEndpoint,
+  match: import_valorant_api_types14.endpoints.currentGameMatchEndpoint,
+  loadouts: currentGameLoadoutsEndpoint,
+  quit: import_valorant_api_types14.endpoints.currentGameQuitEndpoint
+};
+
+// src/api/groups/contracts.ts
+var import_valorant_api_types15 = require("valorant-api-types");
+var contracts = {
+  itemUpgrades: import_valorant_api_types15.endpoints.itemUpgradesEndpoint,
+  list: contractsEndpoint,
+  activate: import_valorant_api_types15.endpoints.activateContractEndpoint,
+  activeRecruitmentEvent: activeRecruitmentEventEndpoint
+};
+
+// src/api/groups/local.ts
+var import_valorant_api_types16 = require("valorant-api-types");
+var local = {
+  help: import_valorant_api_types16.endpoints.localHelpEndpoint,
+  sessions: import_valorant_api_types16.endpoints.sessionsEndpoint,
+  rsoUserInfo: import_valorant_api_types16.endpoints.rsoUserInfoEndpoint,
+  clientRegion: import_valorant_api_types16.endpoints.clientRegionEndpoint,
+  accountAlias: import_valorant_api_types16.endpoints.accountAliasEndpoint,
+  entitlementsToken: import_valorant_api_types16.endpoints.entitlementsTokenEndpoint,
+  chatSession: import_valorant_api_types16.endpoints.chatSessionEndpoint,
+  friends: import_valorant_api_types16.endpoints.friendsEndpoint,
+  sendFriendRequest: import_valorant_api_types16.endpoints.sendFriendRequestEndpoint,
+  removeFriendRequest: import_valorant_api_types16.endpoints.removeFriendRequestEndpoint,
+  presence: presenceEndpoint,
+  friendRequests: import_valorant_api_types16.endpoints.friendRequestsEndpoint,
+  swaggerDocs: import_valorant_api_types16.endpoints.localSwaggerDocsEndpoint,
+  eula: localEulaEndpoint,
+  privacyPolicy: localPrivacyPolicyEndpoint,
+  availableLocales: localAvailableLocalesEndpoint,
+  locale: localLocaleEndpoint,
+  riotStatus: localRiotStatusEndpoint,
+  accessToken: localAccessTokenEndpoint,
+  pluginStatus: localPluginStatusEndpoint,
+  rmsSession: localRmsSessionEndpoint,
+  processInfo: localProcessInfoEndpoint,
+  logPath: localLogPathEndpoint
+};
+
+// src/api/groups/chat.ts
+var import_valorant_api_types17 = require("valorant-api-types");
+var chat = {
+  partyInfo: import_valorant_api_types17.endpoints.partyChatInfoEndpoint,
+  pregameInfo: import_valorant_api_types17.endpoints.pregameChatInfoEndpoint,
+  currentGameInfo: import_valorant_api_types17.endpoints.currentGameChatInfoEndpoint,
+  allInfo: import_valorant_api_types17.endpoints.allChatInfoEndpoint,
+  participants: chatParticipantsEndpoint,
+  send: import_valorant_api_types17.endpoints.sendChatEndpoint,
+  history: import_valorant_api_types17.endpoints.chatHistoryEndpoint,
+  settings: chatSettingsEndpoint,
+  tournamentInfo: chatTournamentInfoEndpoint
+};
+
+// src/api/groups/voice.ts
+var voice = {
+  audioProperties: voiceAudioPropertiesEndpoint,
+  captureDevices: voiceCaptureDevicesEndpoint,
+  renderDevices: voiceRenderDevicesEndpoint
+};
+
+// src/api/groups/premier.ts
+var premier = {
+  seasons: premierSeasonsEndpoint,
+  activeSeason: premierActiveSeasonEndpoint,
+  conferences: premierConferencesEndpoint,
+  matchLimit: premierMatchLimitEndpoint,
+  eligibility: premierEligibilityEndpoint,
+  playerV2: premierPlayerV2Endpoint,
+  playerV3: premierPlayerV3Endpoint
+};
+
+// src/api/groups/esports.ts
+var esports = {
+  liveEventTimes: esportsLiveEventTimesEndpoint,
+  upcomingMatches: esportsUpcomingMatchesEndpoint,
+  pickemLeagues: esportsPickemLeaguesEndpoint
+};
+
+// src/api/groups/restrictions.ts
+var restrictions = {
+  avoidList: avoidListEndpoint,
+  activeFutureInterventions: activeFutureInterventionsEndpoint
+};
+
+// src/api/groups/account.ts
+var account = {
+  dailyTicket: dailyTicketEndpoint,
+  dailyTicketQueueConfig: dailyTicketQueueConfigEndpoint,
+  favorites: favoritesEndpoint,
+  goldstars: goldstarsEndpoint,
+  goldstarsPlayer: goldstarsPlayerEndpoint,
+  bloomlineQueues: bloomlineQueuesEndpoint,
+  bloomlinePlayer: bloomlinePlayerEndpoint
+};
+
+// src/api/groups/auth.ts
+var import_valorant_api_types18 = require("valorant-api-types");
+var auth = {
+  cookies: import_valorant_api_types18.endpoints.authCookiesEndpoint,
+  request: import_valorant_api_types18.endpoints.authRequestEndpoint,
+  multiFactor: import_valorant_api_types18.endpoints.multiFactorAuthenticationEndpoint,
+  cookieReauth: import_valorant_api_types18.endpoints.cookieReauthEndpoint,
+  entitlement: import_valorant_api_types18.endpoints.entitlementEndpoint,
+  playerInfo: import_valorant_api_types18.endpoints.playerInfoEndpoint,
+  riotGeo: import_valorant_api_types18.endpoints.riotGeoEndpoint,
+  pasToken: import_valorant_api_types18.endpoints.pasTokenEndpoint,
+  riotClientConfig: import_valorant_api_types18.endpoints.riotClientConfigEndpoint
+};
+
+// src/endpoints/catalog/index.ts
+var import_zod19 = require("zod");
+
+// src/endpoints/catalog/factory.ts
+var import_zod17 = 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/endpoints/catalog/factory.ts
+var BASE = "https://valorant-api.com/v1/";
+function query(queryParams = []) {
+  return new Map([
+    ["language", import_zod17.z.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
+    ...queryParams
+  ]);
+}
+function endpoint(name, description, path, schema, queryParams = []) {
+  return markEnveloped({
+    name,
+    description,
+    category: "Valorant-API.com",
+    type: "other",
+    suffix: `${BASE}${path}`,
+    query: query(queryParams),
+    responses: { "200": schema }
+  });
+}
+function collection(title, singular, path, schema, queryParams = []) {
+  return {
+    list: endpoint(title, `List of ${title.toLowerCase()}`, path, import_zod17.z.array(schema), queryParams),
+    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
+  };
+}
+
+// src/endpoints/catalog/schemas.ts
+var import_zod18 = require("zod");
+var text = import_zod18.z.string().nullish();
+var asset = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  displayName: text,
+  displayIcon: text,
+  assetPath: text
+}).passthrough();
+var agentSchema = asset.extend({
+  description: text,
+  developerName: text,
+  characterTags: import_zod18.z.array(import_zod18.z.string()).nullish(),
+  displayIconSmall: text,
+  bustPortrait: text,
+  fullPortrait: text,
+  killfeedPortrait: text,
+  background: text,
+  isPlayableCharacter: import_zod18.z.boolean(),
+  role: import_zod18.z.object({ uuid: import_zod18.z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: import_zod18.z.array(import_zod18.z.object({ slot: import_zod18.z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+});
+var mapSchema = asset.extend({
+  coordinates: text,
+  listViewIcon: text,
+  splash: text,
+  mapUrl: text,
+  xMultiplier: import_zod18.z.number(),
+  yMultiplier: import_zod18.z.number(),
+  xScalarToAdd: import_zod18.z.number(),
+  yScalarToAdd: import_zod18.z.number(),
+  callouts: import_zod18.z.array(import_zod18.z.object({ regionName: import_zod18.z.string(), superRegionName: import_zod18.z.string(), location: import_zod18.z.object({ x: import_zod18.z.number(), y: import_zod18.z.number() }) }).passthrough()).nullish()
+});
+var weaponSchema = asset.extend({
+  category: import_zod18.z.string(),
+  defaultSkinUuid: import_zod18.z.string(),
+  killStreamIcon: text,
+  weaponStats: import_zod18.z.object({}).passthrough().nullish(),
+  shopData: import_zod18.z.object({}).passthrough().nullish(),
+  skins: import_zod18.z.array(import_zod18.z.object({}).passthrough())
+});
+var skinSchema = asset.extend({
+  themeUuid: import_zod18.z.string(),
+  contentTierUuid: text,
+  wallpaper: text,
+  chromas: import_zod18.z.array(asset.passthrough()),
+  levels: import_zod18.z.array(asset.passthrough())
+});
+var seasonSchema = import_zod18.z.object({
+  uuid: import_zod18.z.string(),
+  displayName: text,
+  type: text,
+  startTime: import_zod18.z.string(),
+  endTime: import_zod18.z.string(),
+  parentUuid: text,
+  assetPath: text
 }).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()
+var versionSchema = import_zod18.z.object({
+  manifestId: import_zod18.z.string(),
+  branch: import_zod18.z.string(),
+  version: import_zod18.z.string(),
+  buildVersion: import_zod18.z.string(),
+  engineVersion: import_zod18.z.string(),
+  riotClientVersion: import_zod18.z.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: import_zod18.z.string(),
+  buildDate: import_zod18.z.string()
 }).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/endpoints/catalog/index.ts
+var playable = [["isPlayableCharacter", import_zod19.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_zod19.z.object({ uuid: import_zod19.z.string(), tiers: import_zod19.z.array(import_zod19.z.object({ tier: import_zod19.z.number(), tierName: text, division: text, color: text }).passthrough()) }).passthrough());
+var contentTiers = collection("Content Tiers", "Content Tier", "contenttiers", asset);
+var contracts2 = 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_zod19.z.object({ uuid: import_zod19.z.string(), displayName: text }).passthrough());
+var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", import_zod19.z.object({ uuid: import_zod19.z.string(), displayName: text, titleText: text }).passthrough());
+var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", import_zod19.z.object({ uuid: import_zod19.z.string(), seasonUuid: import_zod19.z.string(), startTime: import_zod19.z.string(), endTime: import_zod19.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: contracts2.list,
+  contract: contracts2.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/api/groups/catalog.ts
+var catalog = catalogEndpoints;
+
 // 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
+  pvp,
+  party,
+  store,
+  pregame,
+  currentGame,
+  contracts,
+  local,
+  chat,
+  voice,
+  premier,
+  esports,
+  restrictions,
+  account,
+  auth,
+  catalog
 };
 
 // src/auth.ts
-var import_valorant_api_types2 = require("valorant-api-types");
+var import_valorant_api_types19 = require("valorant-api-types");
 
 // src/errors.ts
 var ValorantError = class extends Error {
@@ -948,7 +2605,7 @@ function createAuthFlows(client) {
       return toLoginResult(data);
     },
     async reauthenticate(options) {
-      const response = await client.send(import_valorant_api_types2.endpoints.cookieReauthEndpoint);
+      const response = await client.send(import_valorant_api_types19.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);
@@ -980,7 +2637,7 @@ function createAuthFlows(client) {
 }
 
 // src/context.ts
-var DEFAULT_PLATFORM = btoa(JSON.stringify({
+var DEFAULT_PLATFORM = toBase64(JSON.stringify({
   platformType: "PC",
   platformOS: "Windows",
   platformOSVersion: "10.0.19042.1.256.64bit",
@@ -1139,6 +2796,258 @@ var localTransport = async (request) => {
   });
 };
 
+// src/internal/body.ts
+var import_zod20 = require("zod");
+function parseBody(text2) {
+  if (text2 === "") return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function safeParse(schema, data) {
+  try {
+    return schema.safeParse(data);
+  } catch (thrown) {
+    if (thrown instanceof import_zod20.ZodError) return { success: false, error: thrown };
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return { success: false, error: new import_zod20.ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
+  }
+}
+
+// src/internal/cookies.ts
+function storeCookies(context, 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");
+    context.setCookie(name, expired ? void 0 : value);
+  }
+}
+
+// src/internal/retry.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE"]);
+function isIdempotent(method) {
+  return IDEMPOTENT.has(method);
+}
+function isRetryableStatus(status, method) {
+  return RETRYABLE_STATUS.has(status) && (status === 429 || isIdempotent(method));
+}
+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/internal/failure.ts
+function toApiError(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);
+}
+
+// src/internal/normalize.ts
+var import_zod21 = require("zod");
+var cache = /* @__PURE__ */ new WeakMap();
+var children = {
+  ZodObject: (def, map) => {
+    const shape = def["shape"]();
+    return { ...def, shape: () => Object.fromEntries(Object.entries(shape).map(([key, value]) => [key, map(value)])) };
+  },
+  ZodArray: (def, map) => ({ ...def, type: map(def["type"]) }),
+  ZodOptional: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodNullable: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodDefault: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodCatch: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodReadonly: (def, map) => ({ ...def, innerType: map(def["innerType"]) }),
+  ZodBranded: (def, map) => ({ ...def, type: map(def["type"]) }),
+  ZodEffects: (def, map) => ({ ...def, schema: map(def["schema"]) }),
+  ZodUnion: (def, map) => ({ ...def, options: def["options"].map(map) }),
+  ZodIntersection: (def, map) => ({ ...def, left: map(def["left"]), right: map(def["right"]) }),
+  ZodRecord: (def, map) => ({ ...def, keyType: map(def["keyType"]), valueType: map(def["valueType"]) }),
+  ZodTuple: (def, map) => ({ ...def, items: def["items"].map(map) }),
+  ZodDiscriminatedUnion: (def, map) => {
+    const optionsMap = new Map([...def["optionsMap"]].map(([key, option]) => [key, map(option)]));
+    return { ...def, options: [...optionsMap.values()], optionsMap };
+  }
+};
+function lenientPc(literal) {
+  return import_zod21.z.preprocess((value) => typeof value === "string" ? value.toUpperCase() : value, literal);
+}
+function normalizePlatformLiterals(schema) {
+  const known = cache.get(schema);
+  if (known) return known;
+  const def = schema._def;
+  let result = schema;
+  if (def.typeName === "ZodLiteral" && def["value"] === "PC") {
+    result = lenientPc(schema);
+  } else if (def.typeName === "ZodLazy") {
+    const getter = def["getter"];
+    result = new schema.constructor({ ...def, getter: () => normalizePlatformLiterals(getter()) });
+  } else if (def.typeName && children[def.typeName]) {
+    const Type = schema.constructor;
+    result = new Type(children[def.typeName](def, normalizePlatformLiterals));
+  }
+  cache.set(schema, result);
+  return result;
+}
+
+// src/lobby/mappings.ts
+var CustomGameTeam = {
+  Defenders: "TeamOne",
+  Attackers: "TeamTwo",
+  Spectators: "TeamSpectate",
+  DefenderCoaches: "TeamOneCoaches",
+  AttackerCoaches: "TeamTwoCoaches"
+};
+var MEMBERSHIP_KEY = {
+  TeamOne: "teamOne",
+  TeamTwo: "teamTwo",
+  TeamSpectate: "teamSpectate",
+  TeamOneCoaches: "teamOneCoaches",
+  TeamTwoCoaches: "teamTwoCoaches"
+};
+var CustomGameMap = {
+  Ascent: "/Game/Maps/Ascent/Ascent",
+  Split: "/Game/Maps/Bonsai/Bonsai",
+  Fracture: "/Game/Maps/Canyon/Canyon",
+  Bind: "/Game/Maps/Duality/Duality",
+  Breeze: "/Game/Maps/Foxtrot/Foxtrot",
+  Abyss: "/Game/Maps/Infinity/Infinity",
+  Lotus: "/Game/Maps/Jam/Jam",
+  Sunset: "/Game/Maps/Juliett/Juliett",
+  Pearl: "/Game/Maps/Pitt/Pitt",
+  Summit: "/Game/Maps/Plummet/Plummet",
+  Icebox: "/Game/Maps/Port/Port",
+  Corrode: "/Game/Maps/Rook/Rook",
+  Haven: "/Game/Maps/Triad/Triad"
+};
+var CustomGameMode = {
+  Standard: "/Game/GameModes/Bomb/BombGameMode.BombGameMode_C",
+  SpikeRush: "/Game/GameModes/QuickBomb/QuickBombGameMode.QuickBombGameMode_C",
+  Deathmatch: "/Game/GameModes/Deathmatch/DeathmatchGameMode.DeathmatchGameMode_C",
+  Escalation: "/Game/GameModes/GunGame/GunGameTeamsGameMode.GunGameTeamsGameMode_C",
+  Skirmish: "/Game/GameModes/Skirmish/SkirmishGameMode.SkirmishGameMode_C"
+};
+var RULE_KEY = {
+  allowGameModifiers: "AllowGameModifiers",
+  playOutAllRounds: "PlayOutAllRounds",
+  skipMatchHistory: "SkipMatchHistory",
+  tournamentMode: "TournamentMode",
+  overtimeWinByTwo: "IsOvertimeWinByTwo"
+};
+function reverse(table) {
+  return new Map(Object.entries(table).map(([name, value]) => [value, name]));
+}
+var mapNames = reverse(CustomGameMap);
+var modeNames = reverse(CustomGameMode);
+function customGameMapName(path) {
+  return mapNames.get(path);
+}
+function customGameModeName(path) {
+  return modeNames.get(path);
+}
+function teamOfPlayer(membership, puuid) {
+  for (const team of Object.values(CustomGameTeam)) {
+    if (membership[MEMBERSHIP_KEY[team]]?.some((member) => member.Subject === puuid)) return team;
+  }
+  return void 0;
+}
+
+// src/lobby/flows.ts
+var DEFAULT_RULES = {
+  AllowGameModifiers: "false",
+  PlayOutAllRounds: "false",
+  SkipMatchHistory: "false",
+  TournamentMode: "false",
+  IsOvertimeWinByTwo: "false"
+};
+function ruleStrings(rules) {
+  const out = {};
+  for (const [name, key] of Object.entries(RULE_KEY)) {
+    const value = rules?.[name];
+    if (value !== void 0) out[key] = value ? "true" : "false";
+  }
+  return out;
+}
+function currentRules(gameRules) {
+  const out = {};
+  for (const key of Object.keys(DEFAULT_RULES)) {
+    const value = gameRules?.[key];
+    if (value === "true" || value === "false") out[key] = value;
+  }
+  return out;
+}
+function createPartyFlows(client) {
+  async function partyIdOf(target) {
+    if (target.partyId !== void 0) return target.partyId;
+    return (await client.party.player({ validation: "off" })).CurrentPartyID;
+  }
+  return {
+    async assignToTeam(team, options = {}) {
+      const partyId = await partyIdOf(options);
+      const puuid = options.puuid ?? client.context.require("puuid");
+      return client.party.setCustomGameTeam({ params: { partyId, team }, body: { playerToPutOnTeam: puuid } });
+    },
+    async configureLobby(options) {
+      const partyId = await partyIdOf(options);
+      const { Settings: current } = (await client.party.getCustomGame({ params: { partyId }, validation: "off" })).CustomGameData;
+      await client.party.setCustomGameSettings({
+        params: { partyId },
+        validation: "off",
+        body: {
+          Map: options.map ?? current.Map,
+          Mode: options.mode ?? current.Mode,
+          UseBots: current.UseBots,
+          GamePod: options.gamePod ?? current.GamePod,
+          GameRules: { ...DEFAULT_RULES, ...currentRules(current.GameRules), ...ruleStrings(options.rules) }
+        }
+      });
+      return (await client.party.getCustomGame({ params: { partyId } })).CustomGameData.Settings;
+    }
+  };
+}
+
+// src/internal/gamelog.ts
+var VERSION_LINE = /CI server version: (release-[\w.]+-shipping-\d+-\d+)/;
+async function readInstalledClientVersion(logPath) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const file = logPath ?? join(process.env["LOCALAPPDATA"] ?? "", "VALORANT", "Saved", "Logs", "ShooterGame.log");
+  try {
+    return VERSION_LINE.exec(await readFile(file, "latin1"))?.[1];
+  } catch {
+    return void 0;
+  }
+}
+
 // src/local.ts
 function parseLockfile(content) {
   const [name, pid, port, password, protocol] = content.trim().split(":");
@@ -1166,7 +3075,6 @@ function createLocalFlows(client) {
       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) });
       }
@@ -1175,9 +3083,9 @@ function createLocalFlows(client) {
         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);
-      }
+      const installed = await readInstalledClientVersion(options?.gameLogPath);
+      if (installed !== void 0) ctx.set("clientVersion", installed);
+      else if (options?.fetchClientVersion !== false) await client.auth.fetchClientVersion().catch(() => void 0);
     },
     async events() {
       return openEventStream(ctx);
@@ -1196,7 +3104,7 @@ async function openEventStream(ctx) {
     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")}`)}` },
+    headers: { Authorization: basicAuth("riot", ctx.require("localPassword")) },
     rejectUnauthorized: false
   });
   const listeners = /* @__PURE__ */ new Set();
@@ -1222,8 +3130,20 @@ async function openEventStream(ctx) {
   };
 }
 
+// src/pregame/flows.ts
+function createPregameFlows(client) {
+  return {
+    async pickAgent(agent, options = {}) {
+      const preGameMatchId = options.matchId ?? (await client.pregame.player({ validation: "off" })).MatchID;
+      const params = { preGameMatchId, agentId: agent };
+      const selected = await client.pregame.selectCharacter({ params });
+      return options.lock ? client.pregame.lockCharacter({ params }) : selected;
+    }
+  };
+}
+
 // src/request.ts
-var import_valorant_api_types3 = require("valorant-api-types");
+var import_valorant_api_types20 = require("valorant-api-types");
 
 // src/types.ts
 function paramName(variable) {
@@ -1250,11 +3170,11 @@ 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") });
+      return (0, import_valorant_api_types20.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") });
+      return (0, import_valorant_api_types20.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") });
+      return (0, import_valorant_api_types20.typeToPrefix)({ type: "local", port: ctx.require("localPort") });
     case "other":
       return "";
   }
@@ -1275,7 +3195,7 @@ function resolveHeaders(endpoint2, input, ctx, url) {
   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.localAuth) headers["Authorization"] = basicAuth("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");
@@ -1304,8 +3224,6 @@ function buildRequest(endpoint2, input, ctx) {
 }
 
 // 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;
@@ -1321,7 +3239,7 @@ var ValorantClient = class {
     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);
+      const parsed = normalizePlatformLiterals(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 ?? {};
@@ -1334,13 +3252,13 @@ var ValorantClient = class {
       try {
         response = await this.#transportFor(endpoint2)({ ...request, signal: this.#signal(input) });
       } catch (cause) {
-        if (canRetry && IDEMPOTENT.has(request.method) && input.signal?.aborted !== true) {
+        if (canRetry && isIdempotent(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);
+      if (isAuthHost(request.url)) storeCookies(this.context, response.setCookies);
       this.#options.logger?.debug?.(`${request.method} ${request.url} -> ${response.status}`);
       if (response.status < 400) {
         return {
@@ -1349,13 +3267,13 @@ var ValorantClient = class {
           data: this.#parseResponse(endpoint2, response, validation)
         };
       }
-      const error = this.#toError(endpoint2, request, response);
+      const error = toApiError(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))) {
+      if (canRetry && isRetryableStatus(response.status, request.method)) {
         const retryAfter = error instanceof ValorantRateLimitError ? error.retryAfterMs : void 0;
         await sleep(retryAfter ?? backoff(attempt, retry), input.signal);
         continue;
@@ -1373,6 +3291,8 @@ var ValorantClient = class {
     }
     Object.assign(api["auth"], createAuthFlows(this));
     Object.assign(api["local"], createLocalFlows(this));
+    Object.assign(api["party"], createPartyFlows(this));
+    Object.assign(api["pregame"], createPregameFlows(this));
     return api;
   }
   #transportFor(endpoint2) {
@@ -1387,20 +3307,10 @@ var ValorantClient = class {
     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)];
+    const published = endpoint2.responses?.[String(response.status)];
+    const schema = published && normalizePlatformLiterals(published);
     if (schema === void 0 || validation === "off") return data;
     const parsed = safeParse(schema, data);
     if (parsed.success) return parsed.data;
@@ -1411,15 +3321,6 @@ var ValorantClient = class {
     }
     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;
@@ -1427,51 +3328,54 @@ var ValorantClient = class {
     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/pregame/agents.ts
+var Agent = {
+  Astra: "41fb69c1-4189-7b37-f117-bcaf1e96f1bf",
+  Breach: "5f8d3a7f-467b-97f3-062c-13acf203c006",
+  Brimstone: "9f0d8ba9-4140-b941-57d3-a7ad57c6b417",
+  Chamber: "22697a3d-45bf-8dd7-4fec-84a9e28c69d7",
+  Clove: "1dbf2edd-4729-0984-3115-daa5eed44993",
+  Cypher: "117ed9e3-49f3-6512-3ccf-0cada7e3823b",
+  Deadlock: "cc8b64c8-4b25-4ff9-6e7f-37b4da43d235",
+  Fade: "dade69b4-4f5a-8528-247b-219e5a1facd6",
+  Gekko: "e370fa57-4757-3604-3648-499e1f642d3f",
+  Harbor: "95b78ed7-4637-86d9-7e41-71ba8c293152",
+  Hush: "ddd5a15c-4fbe-42fa-3789-11a55ca5ee04",
+  Iso: "0e38b510-41a8-5780-5e8f-568b2a4f2d6c",
+  Jett: "add6443a-41bd-e414-f6ad-e58d267f4e95",
+  KayO: "601dbbe7-43ce-be57-2a40-4abd24953621",
+  Killjoy: "1e58de9c-4950-5125-93e9-a0aee9f98746",
+  Miks: "7c8a4701-4de6-9355-b254-e09bc2a34b72",
+  Neon: "bb2a4828-46eb-8cd1-e765-15848195d751",
+  Omen: "8e253930-4c05-31dd-1b6c-968525494517",
+  Phoenix: "eb93336a-449b-9c1b-0a54-a891f7921d69",
+  Raze: "f94c3b30-42be-e959-889c-5aa313dba261",
+  Reyna: "a3bfb853-43b2-7238-a4f1-ad90e9e46bcc",
+  Sage: "569fdd95-4d10-43ab-ca70-79becc718b46",
+  Skye: "6f2a04ca-43e0-be17-7f36-b3908627744d",
+  Sova: "320b2a48-4d9b-a075-30f1-1f93a9b638fa",
+  Tejo: "b444168c-4e35-8076-db47-ef9bf368f384",
+  Veto: "92eeef5d-43b5-1d4a-8d03-b3927a09034b",
+  Viper: "707eab51-4836-f488-046a-cda6bf494859",
+  Vyse: "efba5359-4016-a1e5-7626-b1ae76895940",
+  Waylay: "df1cb487-4902-002e-5c17-d28e83e78588",
+  Yoru: "7f94d92c-4234-0a36-9646-3a87eb8b5c89"
+};
+var names = new Map(Object.entries(Agent).map(([name, id]) => [id, name]));
+function agentName(id) {
+  return names.get(id);
 }
 
 // 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 = {
+  Agent,
+  CustomGameMap,
+  CustomGameMode,
+  CustomGameTeam,
+  MEMBERSHIP_KEY,
   MissingContextError,
   MissingParameterError,
   ValorantApiError,
@@ -1482,6 +3386,9 @@ __reExport(index_exports, require("valorant-api-types"), module.exports);
   ValorantNetworkError,
   ValorantRateLimitError,
   ValorantValidationError,
+  agentName,
+  customGameMapName,
+  customGameModeName,
   fetchTransport,
   isRegion,
   localTransport,
@@ -1490,6 +3397,7 @@ __reExport(index_exports, require("valorant-api-types"), module.exports);
   readLockfile,
   registry,
   shardForRegion,
+  teamOfPlayer,
   ...require("valorant-api-types")
 });
 //# sourceMappingURL=index.cjs.map