@voxary/valorant-client 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -52,774 +52,1889 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/client.ts
-var import_zod4 = require("zod");
-
-// src/api/registry.ts
+// src/api/groups/pvp.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;
-}
-function unwrapEnvelope(endpoint2, body) {
-  if (enveloped.has(endpoint2) && typeof body === "object" && body !== null && "data" in body) {
-    return body.data;
-  }
-  return body;
-}
+// src/endpoints/riot/shared.ts
+var player = { token: true, entitlement: true, clientVersion: true, clientPlatform: true };
 
-// 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/chat.ts
 var import_zod2 = require("zod");
-var contractsActiveStoryEndpoint = {
-  name: "Active Story",
-  description: "Get the battlepass contracts",
-  queryName: "ContractDefinitions_FetchActiveStory",
-  category: "Contract Endpoints",
-  type: "pd",
-  suffix: "contract-definitions/v2/definitions/story",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": import_zod2.z.unknown() }
-};
-var currentGameAllChatTokenEndpoint = {
-  name: "All Chat Token",
-  description: "Get a token for all chat",
-  queryName: "CoreGame_FetchAllChatMUCToken",
-  category: "Current Game Endpoints",
-  type: "glz",
-  suffix: "core-game/v1/matches/{in-progress match id}/allchatmuctoken",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": import_zod2.z.unknown() }
-};
-var currentGameTeamChatTokenEndpoint = {
-  name: "Team Chat Token",
-  description: "Get a token for team chat",
-  queryName: "CoreGame_FetchTeamChatMUCToken",
-  category: "Current Game Endpoints",
-  type: "glz",
-  suffix: "core-game/v1/matches/{in-progress match id}/teamchatmuctoken",
-  riotRequirements: { entitlement: true, token: true, clientPlatform: true, clientVersion: true },
-  responses: { "200": import_zod2.z.unknown() }
-};
-var localAntiAddictionShutdownEndpoint = {
-  name: "Anti Addiction Shutdown",
-  description: "GET ANTI_ADDICTION_RNet_FetchShutdownPolicyState",
-  queryName: "ANTI_ADDICTION_RNet_FetchShutdownPolicyState",
-  category: "Local Endpoints",
+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_zod2.z.object({
+    bounceDockIconEnabled: import_zod2.z.boolean(),
+    "chat-status-message": import_zod2.z.string(),
+    chatFilterDisabled: import_zod2.z.boolean(),
+    chatGBG: import_zod2.z.boolean(),
+    chatGroupDiscord: import_zod2.z.boolean(),
+    chatGroupMobile: import_zod2.z.boolean(),
+    chatGroupOffline: import_zod2.z.boolean(),
+    chatWindow: import_zod2.z.object({
+      detached: import_zod2.z.boolean(),
+      height: import_zod2.z.number(),
+      left: import_zod2.z.number(),
+      top: import_zod2.z.number(),
+      width: import_zod2.z.number()
+    }),
+    chatWindowDockedHeight: import_zod2.z.number(),
+    "closed-conversations": import_zod2.z.object({
+      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": import_zod2.z.number()
+    }),
+    friendRequestToastsDisabled: import_zod2.z.boolean(),
+    "hidden-conversations": import_zod2.z.object({}),
+    linkClickWarningEnabled: import_zod2.z.boolean(),
+    messageNotificationsEnabled: import_zod2.z.boolean(),
+    moreUnreadsEnabled: import_zod2.z.boolean(),
+    "muted-conversations": import_zod2.z.object({}),
+    recentlyPlayedFirstOpen: import_zod2.z.boolean(),
+    recentlyPlayedOpen: import_zod2.z.boolean(),
+    "roster-group-collapsed": import_zod2.z.object({}),
+    showWhenTypingEnabled: import_zod2.z.boolean(),
+    sortBy: import_zod2.z.string(),
+    usePlayerPreferences: import_zod2.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_zod2.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() }
+
+// src/endpoints/riot/contracts.ts
+var import_zod3 = 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_zod3.z.object({
+    AgentID: import_zod3.z.string(),
+    CounterID: import_zod3.z.string(),
+    MilestoneThreshold: import_zod3.z.number(),
+    StartDate: import_zod3.z.string(),
+    EndDate: import_zod3.z.string(),
+    IsActive: import_zod3.z.boolean(),
+    includedPlatforms: import_zod3.z.object({
+      console: import_zod3.z.object({
+        developmentOnly: import_zod3.z.boolean()
+      }),
+      mobile: import_zod3.z.object({
+        developmentOnly: import_zod3.z.boolean()
+      }),
+      pc: import_zod3.z.object({
+        developmentOnly: import_zod3.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() }
+
+// src/endpoints/riot/esports.ts
+var import_zod4 = 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_zod4.z.object({
+    Tournaments: import_zod4.z.array(import_zod4.z.object({
+      ID: import_zod4.z.string(),
+      StartTimeUTC: import_zod4.z.string(),
+      EndTimeUTC: import_zod4.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_zod4.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_zod4.z.object({
+    PickemLeagues: import_zod4.z.array(import_zod4.z.object({
+      LeagueID: import_zod4.z.string(),
+      EldsLeagueID: import_zod4.z.string(),
+      Tournament: import_zod4.z.object({
+        ID: import_zod4.z.string(),
+        EldsTournamentID: import_zod4.z.string(),
+        LeagueID: import_zod4.z.string(),
+        PickBlocks: import_zod4.z.array(import_zod4.z.object({
+          ID: import_zod4.z.string(),
+          EldsTournamentID: import_zod4.z.string(),
+          Slug: import_zod4.z.object({
+            Slug: import_zod4.z.string()
+          }),
+          PickOpenTime: import_zod4.z.string(),
+          PickCloseTime: import_zod4.z.string(),
+          State: import_zod4.z.string(),
+          OpenLevel: import_zod4.z.string(),
+          BlockType: import_zod4.z.string(),
+          PickBlockElements: import_zod4.z.array(import_zod4.z.object({
+            ID: import_zod4.z.string(),
+            PickBlockID: import_zod4.z.string(),
+            Section: import_zod4.z.object({
+              ID: import_zod4.z.string(),
+              EldsSectionID: import_zod4.z.string(),
+              CorrectPick: import_zod4.z.object({
+                Entries: import_zod4.z.array(import_zod4.z.object({
+                  Index: import_zod4.z.number(),
+                  Correctness: import_zod4.z.string(),
+                  ParticipantID: import_zod4.z.string(),
+                  Points: import_zod4.z.number(),
+                  Rank: import_zod4.z.number()
+                })).nullable()
+              })
+            }),
+            Match: import_zod4.z.object({
+              ID: import_zod4.z.string(),
+              EldsMatchID: import_zod4.z.string(),
+              BaselinePoints: import_zod4.z.number(),
+              CorrectPick: import_zod4.z.string(),
+              ResultState: import_zod4.z.string()
+            }),
+            PickOpenTime: import_zod4.z.string(),
+            PickCloseTime: import_zod4.z.string(),
+            State: import_zod4.z.string(),
+            DisplayOrder: import_zod4.z.number()
+          })),
+          CompletionStatus: import_zod4.z.string()
+        })),
+        Participants: import_zod4.z.array(import_zod4.z.object({
+          ID: import_zod4.z.string(),
+          EldsTeamID: import_zod4.z.string()
+        }))
+      }),
+      Published: import_zod4.z.boolean()
+    }))
+  }) }
 };
+
+// src/endpoints/riot/local.ts
+var import_zod5 = 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() }
-};
-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() }
+  responses: { "200": import_zod5.z.string() }
 };
-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_zod5.z.array(import_zod5.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_zod5.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_zod5.z.object({
+    clientId: import_zod5.z.string(),
+    expiry: import_zod5.z.number(),
+    scopes: import_zod5.z.array(import_zod5.z.string()),
+    token: import_zod5.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_zod5.z.object({
+    state: import_zod5.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_zod5.z.object({
+    state: import_zod5.z.string(),
+    token: import_zod5.z.string(),
+    tokenType: import_zod5.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_zod5.z.object({
+    pid: import_zod5.z.number(),
+    status: import_zod5.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_zod5.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_zod5.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_zod5.z.string() }
+};
+
+// src/endpoints/riot/premier.ts
+var import_zod6 = 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_zod6.z.object({
+    PremierSeasons: import_zod6.z.array(import_zod6.z.object({
+      ID: import_zod6.z.string(),
+      Name: import_zod6.z.string(),
+      PreviousPremierSeasonID: import_zod6.z.string(),
+      NextPremierSeasonID: import_zod6.z.string(),
+      IsActive: import_zod6.z.boolean(),
+      StartTime: import_zod6.z.string(),
+      EndTime: import_zod6.z.string(),
+      Events: import_zod6.z.array(import_zod6.z.object({
+        ID: import_zod6.z.string(),
+        Type: import_zod6.z.string(),
+        StartDateTime: import_zod6.z.string(),
+        EndDateTime: import_zod6.z.string(),
+        MapSelectionStrategy: import_zod6.z.string(),
+        MapPoolMapIDs: import_zod6.z.array(import_zod6.z.string()),
+        PointsRequiredToParticipate: import_zod6.z.number()
+      })),
+      ScheduledEvents: import_zod6.z.array(import_zod6.z.object({
+        EventID: import_zod6.z.string(),
+        EventType: import_zod6.z.string(),
+        Conference: import_zod6.z.string(),
+        DivisionGroup: import_zod6.z.string(),
+        EventPresetName: import_zod6.z.string(),
+        StartDateTime: import_zod6.z.string(),
+        EndDateTime: import_zod6.z.string(),
+        TournamentRoundTimes: import_zod6.z.array(import_zod6.z.object({
+          StartDateTime: import_zod6.z.string(),
+          EndDateTime: import_zod6.z.string()
+        }))
+      })),
+      Conferences: import_zod6.z.array(import_zod6.z.object({
+        id: import_zod6.z.string(),
+        key: import_zod6.z.string(),
+        isSuper: import_zod6.z.boolean(),
+        gamePods: import_zod6.z.array(import_zod6.z.string()),
+        timezone: import_zod6.z.string(),
+        superConference: import_zod6.z.string().optional(),
+        leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+        leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+      })),
+      Divisions: import_zod6.z.array(import_zod6.z.object({
+        Division: import_zod6.z.number(),
+        DivisionName: import_zod6.z.string(),
+        DivisionGroup: import_zod6.z.string(),
+        EventPresetName: import_zod6.z.string()
+      })),
+      DivisionThresholds: import_zod6.z.array(import_zod6.z.object({
+        playoffThresholdType: import_zod6.z.string(),
+        playoffThresholdValue: import_zod6.z.number(),
+        promotionThresholdType: import_zod6.z.string(),
+        promotionThresholdValue: import_zod6.z.number(),
+        shouldPromoteToSuperConference: import_zod6.z.boolean(),
+        skipReseedCriteria: import_zod6.z.string(),
+        conference: import_zod6.z.string().optional(),
+        division: import_zod6.z.number().optional(),
+        promotionConference: import_zod6.z.string().optional(),
+        skipReseedCriteriaValue: import_zod6.z.number().optional()
+      })),
+      EventPresets: import_zod6.z.object({
+        PRO: import_zod6.z.object({
+          EventPresetsByEventType: import_zod6.z.object({
+            LEAGUE: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            SCRIM: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            TOURNAMENT: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            })
+          })
+        }),
+        REGULAR: import_zod6.z.object({
+          EventPresetsByEventType: import_zod6.z.object({
+            LEAGUE: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            SCRIM: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            TOURNAMENT: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            })
+          })
+        })
+      }),
+      FlawlessPointRequirement: import_zod6.z.number(),
+      ChampionshipPointRequirement: import_zod6.z.number(),
+      ChampionshipEventID: import_zod6.z.string(),
+      EnrollmentPhaseStartDateTime: import_zod6.z.string(),
+      EnrollmentPhaseEndDateTime: import_zod6.z.string(),
+      LeaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+      LeaderboardPromotionFinalizationDateTime: import_zod6.z.string(),
+      LeaderboardFinalizationDateTime: import_zod6.z.string(),
+      ContenderEligibilityExpiryDateTime: import_zod6.z.string(),
+      StageLockTime: import_zod6.z.string(),
+      ParticipationRewardsActIDs: import_zod6.z.array(import_zod6.z.string()),
+      ParticipationRewards: import_zod6.z.object({
+        EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+          ItemTypeID: import_zod6.z.string(),
+          ItemID: import_zod6.z.string(),
+          Amount: import_zod6.z.number()
+        }))
+      }),
+      TournamentWinnerRewards: import_zod6.z.object({}),
+      DivisionWinnerRewards: import_zod6.z.object({
+        ADVANCED: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        CONTENDER: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        ELITE: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        INTERMEDIATE: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        OPEN: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        INVITE: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional()
+      }),
+      RosterRecentActivityNumSeasons: import_zod6.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_zod6.z.object({
+    ID: import_zod6.z.string(),
+    Name: import_zod6.z.string(),
+    PreviousPremierSeasonID: import_zod6.z.string(),
+    NextPremierSeasonID: import_zod6.z.string(),
+    IsActive: import_zod6.z.boolean(),
+    StartTime: import_zod6.z.string(),
+    EndTime: import_zod6.z.string(),
+    Events: import_zod6.z.array(import_zod6.z.object({
+      ID: import_zod6.z.string(),
+      Type: import_zod6.z.string(),
+      StartDateTime: import_zod6.z.string(),
+      EndDateTime: import_zod6.z.string(),
+      MapSelectionStrategy: import_zod6.z.string(),
+      MapPoolMapIDs: import_zod6.z.array(import_zod6.z.string()),
+      PointsRequiredToParticipate: import_zod6.z.number()
+    })),
+    ScheduledEvents: import_zod6.z.array(import_zod6.z.object({
+      EventID: import_zod6.z.string(),
+      EventType: import_zod6.z.string(),
+      Conference: import_zod6.z.string(),
+      DivisionGroup: import_zod6.z.string(),
+      EventPresetName: import_zod6.z.string(),
+      StartDateTime: import_zod6.z.string(),
+      EndDateTime: import_zod6.z.string(),
+      TournamentRoundTimes: import_zod6.z.array(import_zod6.z.object({
+        StartDateTime: import_zod6.z.string(),
+        EndDateTime: import_zod6.z.string()
+      }))
+    })),
+    Conferences: import_zod6.z.array(import_zod6.z.object({
+      id: import_zod6.z.string(),
+      key: import_zod6.z.string(),
+      isSuper: import_zod6.z.boolean(),
+      gamePods: import_zod6.z.array(import_zod6.z.string()),
+      timezone: import_zod6.z.string(),
+      superConference: import_zod6.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+    })),
+    Divisions: import_zod6.z.array(import_zod6.z.object({
+      Division: import_zod6.z.number(),
+      DivisionName: import_zod6.z.string(),
+      DivisionGroup: import_zod6.z.string(),
+      EventPresetName: import_zod6.z.string()
+    })),
+    DivisionThresholds: import_zod6.z.array(import_zod6.z.object({
+      playoffThresholdType: import_zod6.z.string(),
+      playoffThresholdValue: import_zod6.z.number(),
+      promotionThresholdType: import_zod6.z.string(),
+      promotionThresholdValue: import_zod6.z.number(),
+      shouldPromoteToSuperConference: import_zod6.z.boolean(),
+      skipReseedCriteria: import_zod6.z.string(),
+      conference: import_zod6.z.string().optional(),
+      division: import_zod6.z.number().optional(),
+      promotionConference: import_zod6.z.string().optional(),
+      skipReseedCriteriaValue: import_zod6.z.number().optional()
+    })),
+    EventPresets: import_zod6.z.object({
+      PRO: import_zod6.z.object({
+        EventPresetsByEventType: import_zod6.z.object({
+          LEAGUE: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          SCRIM: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          TOURNAMENT: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          })
+        })
+      }),
+      REGULAR: import_zod6.z.object({
+        EventPresetsByEventType: import_zod6.z.object({
+          LEAGUE: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          SCRIM: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          TOURNAMENT: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          })
+        })
+      })
+    }),
+    FlawlessPointRequirement: import_zod6.z.number(),
+    ChampionshipPointRequirement: import_zod6.z.number(),
+    ChampionshipEventID: import_zod6.z.string(),
+    EnrollmentPhaseStartDateTime: import_zod6.z.string(),
+    EnrollmentPhaseEndDateTime: import_zod6.z.string(),
+    LeaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+    LeaderboardPromotionFinalizationDateTime: import_zod6.z.string(),
+    LeaderboardFinalizationDateTime: import_zod6.z.string(),
+    ContenderEligibilityExpiryDateTime: import_zod6.z.string(),
+    StageLockTime: import_zod6.z.string(),
+    ParticipationRewards: import_zod6.z.object({}),
+    TournamentWinnerRewards: import_zod6.z.object({}),
+    DivisionWinnerRewards: import_zod6.z.object({}),
+    RosterRecentActivityNumSeasons: import_zod6.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_zod6.z.object({
+    PremierConferences: import_zod6.z.array(import_zod6.z.object({
+      id: import_zod6.z.string(),
+      key: import_zod6.z.string(),
+      isSuper: import_zod6.z.boolean(),
+      gamePods: import_zod6.z.array(import_zod6.z.string()),
+      timezone: import_zod6.z.string(),
+      superConference: import_zod6.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod6.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_zod6.z.object({
+    leagueMatchLimit: import_zod6.z.number(),
+    tournamentLimit: import_zod6.z.number(),
+    timeUntilNextResetSeconds: import_zod6.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_zod6.z.object({
+    subject: import_zod6.z.string(),
+    accountVerificationStatus: import_zod6.z.boolean(),
+    rankedPlacementCompletionStatus: import_zod6.z.boolean(),
+    matchLimitReached: import_zod6.z.boolean(),
+    isOnProvidedRoster: import_zod6.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_zod6.z.object({
+    puuid: import_zod6.z.string(),
+    rosterId: import_zod6.z.string(),
+    version: import_zod6.z.number(),
+    createdAt: import_zod6.z.number(),
+    updatedAt: import_zod6.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_zod6.z.object({
+    puuid: import_zod6.z.string(),
+    rosterId: import_zod6.z.string(),
+    prestige: import_zod6.z.object({
+      earnedPrestige: import_zod6.z.boolean(),
+      earnedAura: import_zod6.z.boolean(),
+      showTag: import_zod6.z.boolean(),
+      showPlating: import_zod6.z.boolean(),
+      showAura: import_zod6.z.boolean()
+    }),
+    contenderEligibilityExpiry: import_zod6.z.string(),
+    socialVersion: import_zod6.z.number(),
+    premierVersion: import_zod6.z.number(),
+    updatedAt: import_zod6.z.number(),
+    seasons: import_zod6.z.object({
+      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": import_zod6.z.object({
+        seasonId: import_zod6.z.string(),
+        hasEarnedPrestigeAura: import_zod6.z.boolean(),
+        hasEarnedParticipation: import_zod6.z.boolean(),
+        hasEarnedDivisionWinner: import_zod6.z.boolean()
+      }),
+      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": import_zod6.z.object({
+        seasonId: import_zod6.z.string(),
+        hasEarnedPrestigeAura: import_zod6.z.boolean(),
+        hasEarnedParticipation: import_zod6.z.boolean(),
+        hasEarnedDivisionWinner: import_zod6.z.boolean()
+      })
+    })
+  }) }
+};
+
+// src/endpoints/riot/pvp.ts
+var import_zod7 = 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_zod7.z.object({
+    Subject: import_zod7.z.string(),
+    Version: import_zod7.z.number(),
+    Guns: import_zod7.z.array(import_zod7.z.object({
+      ID: import_zod7.z.string(),
+      SkinID: import_zod7.z.string(),
+      SkinLevelID: import_zod7.z.string(),
+      ChromaID: import_zod7.z.string(),
+      CharmInstanceID: import_zod7.z.string().optional(),
+      CharmID: import_zod7.z.string().optional(),
+      CharmLevelID: import_zod7.z.string().optional()
+    })),
+    ActiveExpressions: import_zod7.z.array(import_zod7.z.object({
+      TypeID: import_zod7.z.string(),
+      AssetID: import_zod7.z.string()
+    })),
+    DynamicOptions: import_zod7.z.object({}),
+    Identity: import_zod7.z.object({
+      PlayerCardID: import_zod7.z.string(),
+      PlayerTitleID: import_zod7.z.string(),
+      AccountLevel: import_zod7.z.number(),
+      PreferredLevelBorderID: import_zod7.z.string(),
+      HideAccountLevel: import_zod7.z.boolean()
+    }),
+    Incognito: import_zod7.z.boolean()
+  }) }
+};
+
+// src/endpoints/riot/restrictions.ts
+var import_zod8 = 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_zod8.z.object({
+    Subject: import_zod8.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_zod8.z.object({
+    Subject: import_zod8.z.string()
+  }) }
+};
+
+// src/endpoints/riot/store.ts
+var import_zod9 = 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_zod9.z.object({
+    AgentStore: import_zod9.z.object({
+      AgentStoreOffers: import_zod9.z.array(import_zod9.z.object({
+        AgentID: import_zod9.z.string(),
+        StoreOffers: import_zod9.z.array(import_zod9.z.object({
+          OfferID: import_zod9.z.string(),
+          IsDirectPurchase: import_zod9.z.boolean(),
+          StartDate: import_zod9.z.string(),
+          Cost: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()),
+          Rewards: import_zod9.z.array(import_zod9.z.object({
+            ItemTypeID: import_zod9.z.string(),
+            ItemID: import_zod9.z.string(),
+            Quantity: import_zod9.z.number()
+          }))
+        }))
+      })),
+      CurrentFeaturedAgent: import_zod9.z.string(),
+      NextFeaturedAgent: import_zod9.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_zod9.z.object({
+    EntitlementsByTypes: import_zod9.z.array(import_zod9.z.object({
+      ItemTypeID: import_zod9.z.string(),
+      Entitlements: import_zod9.z.array(import_zod9.z.object({
+        TypeID: import_zod9.z.string(),
+        ItemID: import_zod9.z.string(),
+        InstanceID: import_zod9.z.string().optional()
+      }))
+    }))
+  }) }
+};
+
+// src/endpoints/riot/storefront.ts
+var import_zod10 = 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_zod10.z.object({
+    FeaturedBundle: import_zod10.z.object({
+      Bundle: import_zod10.z.object({
+        ID: import_zod10.z.string(),
+        DataAssetID: import_zod10.z.string(),
+        CurrencyID: import_zod10.z.string(),
+        Items: import_zod10.z.array(import_zod10.z.object({
+          Item: import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }),
+          BasePrice: import_zod10.z.number(),
+          CurrencyID: import_zod10.z.string(),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedPrice: import_zod10.z.number(),
+          IsPromoItem: import_zod10.z.boolean()
+        })),
+        ItemOffers: import_zod10.z.array(import_zod10.z.object({
+          BundleItemOfferID: import_zod10.z.string(),
+          Offer: import_zod10.z.object({
+            OfferID: import_zod10.z.string(),
+            IsDirectPurchase: import_zod10.z.boolean(),
+            StartDate: import_zod10.z.string(),
+            Cost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            Rewards: import_zod10.z.array(import_zod10.z.object({
+              ItemTypeID: import_zod10.z.string(),
+              ItemID: import_zod10.z.string(),
+              Quantity: import_zod10.z.number()
+            }))
+          }),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedCost: import_zod10.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          })
+        })),
+        TotalBaseCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountedCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountPercent: import_zod10.z.number(),
+        DurationRemainingInSeconds: import_zod10.z.number(),
+        WholesaleOnly: import_zod10.z.boolean(),
+        IsGiftable: import_zod10.z.number()
+      }),
+      Bundles: import_zod10.z.array(import_zod10.z.object({
+        ID: import_zod10.z.string(),
+        DataAssetID: import_zod10.z.string(),
+        CurrencyID: import_zod10.z.string(),
+        Items: import_zod10.z.array(import_zod10.z.object({
+          Item: import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }),
+          BasePrice: import_zod10.z.number(),
+          CurrencyID: import_zod10.z.string(),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedPrice: import_zod10.z.number(),
+          IsPromoItem: import_zod10.z.boolean()
+        })),
+        ItemOffers: import_zod10.z.array(import_zod10.z.object({
+          BundleItemOfferID: import_zod10.z.string(),
+          Offer: import_zod10.z.object({
+            OfferID: import_zod10.z.string(),
+            IsDirectPurchase: import_zod10.z.boolean(),
+            StartDate: import_zod10.z.string(),
+            Cost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            Rewards: import_zod10.z.array(import_zod10.z.object({
+              ItemTypeID: import_zod10.z.string(),
+              ItemID: import_zod10.z.string(),
+              Quantity: import_zod10.z.number()
+            }))
+          }),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedCost: import_zod10.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          })
+        })),
+        TotalBaseCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountedCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountPercent: import_zod10.z.number(),
+        DurationRemainingInSeconds: import_zod10.z.number(),
+        WholesaleOnly: import_zod10.z.boolean(),
+        IsGiftable: import_zod10.z.number()
+      })),
+      FeaturedTileEntries: import_zod10.z.array(import_zod10.z.object({
+        Type: import_zod10.z.number(),
+        Entry: import_zod10.z.object({
+          Bundle: import_zod10.z.object({
+            ID: import_zod10.z.string(),
+            DataAssetID: import_zod10.z.string(),
+            CurrencyID: import_zod10.z.string(),
+            Items: import_zod10.z.array(import_zod10.z.object({
+              Item: import_zod10.z.object({
+                ItemTypeID: import_zod10.z.string(),
+                ItemID: import_zod10.z.string(),
+                Amount: import_zod10.z.number()
+              }),
+              BasePrice: import_zod10.z.number(),
+              CurrencyID: import_zod10.z.string(),
+              DiscountPercent: import_zod10.z.number(),
+              DiscountedPrice: import_zod10.z.number(),
+              IsPromoItem: import_zod10.z.boolean()
+            })),
+            ItemOffers: import_zod10.z.array(import_zod10.z.object({
+              BundleItemOfferID: import_zod10.z.string(),
+              Offer: import_zod10.z.object({
+                OfferID: import_zod10.z.string(),
+                IsDirectPurchase: import_zod10.z.boolean(),
+                StartDate: import_zod10.z.string(),
+                Cost: import_zod10.z.object({
+                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+                }),
+                Rewards: import_zod10.z.array(import_zod10.z.object({
+                  ItemTypeID: import_zod10.z.string(),
+                  ItemID: import_zod10.z.string(),
+                  Quantity: import_zod10.z.number()
+                }))
+              }),
+              DiscountPercent: import_zod10.z.number(),
+              DiscountedCost: import_zod10.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              })
+            })),
+            TotalBaseCost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            TotalDiscountedCost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            TotalDiscountPercent: import_zod10.z.number(),
+            DurationRemainingInSeconds: import_zod10.z.number(),
+            WholesaleOnly: import_zod10.z.boolean(),
+            IsGiftable: import_zod10.z.number()
+          })
+        })
+      })),
+      BundleRemainingDurationInSeconds: import_zod10.z.number()
+    }),
+    SkinsPanelLayout: import_zod10.z.object({
+      SingleItemOffers: import_zod10.z.array(import_zod10.z.string()),
+      SingleItemStoreOffers: import_zod10.z.array(import_zod10.z.object({
+        OfferID: import_zod10.z.string(),
+        IsDirectPurchase: import_zod10.z.boolean(),
+        StartDate: import_zod10.z.string(),
+        Cost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        Rewards: import_zod10.z.array(import_zod10.z.object({
+          ItemTypeID: import_zod10.z.string(),
+          ItemID: import_zod10.z.string(),
+          Quantity: import_zod10.z.number()
+        }))
+      })),
+      SingleItemOffersRemainingDurationInSeconds: import_zod10.z.number()
+    }),
+    UpgradeCurrencyStore: import_zod10.z.object({
+      UpgradeCurrencyOffers: import_zod10.z.array(import_zod10.z.object({
+        OfferID: import_zod10.z.string(),
+        StorefrontItemID: import_zod10.z.string(),
+        Offer: import_zod10.z.object({
+          OfferID: import_zod10.z.string(),
+          IsDirectPurchase: import_zod10.z.boolean(),
+          StartDate: import_zod10.z.string(),
+          Cost: import_zod10.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          }),
+          Rewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Quantity: import_zod10.z.number()
+          }))
+        }),
+        DiscountedPercent: import_zod10.z.number()
+      }))
+    }),
+    AccessoryStore: import_zod10.z.object({
+      AccessoryStoreOffers: import_zod10.z.array(import_zod10.z.object({
+        Offer: import_zod10.z.object({
+          OfferID: import_zod10.z.string(),
+          IsDirectPurchase: import_zod10.z.boolean(),
+          StartDate: import_zod10.z.string(),
+          Cost: import_zod10.z.object({
+            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": import_zod10.z.number()
+          }),
+          Rewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Quantity: import_zod10.z.number()
+          }))
+        }),
+        ContractID: import_zod10.z.string()
+      })),
+      AccessoryStoreRemainingDurationInSeconds: import_zod10.z.number(),
+      StorefrontID: import_zod10.z.string()
+    }),
+    PluginStores: import_zod10.z.array(import_zod10.z.object({
+      PluginID: import_zod10.z.string(),
+      PluginOffers: import_zod10.z.object({
+        StoreOffers: import_zod10.z.array(import_zod10.z.object({
+          PurchaseInformation: import_zod10.z.object({
+            DataAssetID: import_zod10.z.string(),
+            OfferID: import_zod10.z.string(),
+            OfferType: import_zod10.z.number(),
+            StartDate: import_zod10.z.string(),
+            PrimaryCurrencyID: import_zod10.z.string(),
+            Cost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            DiscountedCost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            DiscountedPercentage: import_zod10.z.number(),
+            WholesaleOnly: import_zod10.z.boolean(),
+            IsGiftable: import_zod10.z.number()
+          }),
+          SubOffers: import_zod10.z.array(import_zod10.z.object({
+            PurchaseInformation: import_zod10.z.object({
+              DataAssetID: import_zod10.z.string(),
+              OfferID: import_zod10.z.string(),
+              OfferType: import_zod10.z.number(),
+              StartDate: import_zod10.z.string(),
+              PrimaryCurrencyID: import_zod10.z.string(),
+              Cost: import_zod10.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              }),
+              DiscountedCost: import_zod10.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              }),
+              DiscountedPercentage: import_zod10.z.number(),
+              Rewards: import_zod10.z.array(import_zod10.z.object({
+                ItemTypeID: import_zod10.z.string(),
+                ItemID: import_zod10.z.string(),
+                Quantity: import_zod10.z.number()
+              })),
+              WholesaleOnly: import_zod10.z.boolean(),
+              IsGiftable: import_zod10.z.number()
+            })
+          }))
+        })),
+        RemainingDurationInSeconds: import_zod10.z.number()
+      }),
+      StartDate: import_zod10.z.string()
+    }))
+  }) }
+};
+
+// src/endpoints/riot/voice.ts
+var import_zod11 = 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_zod11.z.object({
+    fastEnergyMeter: import_zod11.z.number(),
+    isLoopbackEnabled: import_zod11.z.boolean(),
+    isMicActive: import_zod11.z.boolean(),
+    isSpeakerActive: import_zod11.z.boolean(),
+    micEnergy: import_zod11.z.number(),
+    micVolume: import_zod11.z.number(),
+    noiseFloorMeter: import_zod11.z.number(),
+    speakerEnergy: import_zod11.z.number(),
+    speakerVolume: import_zod11.z.number(),
+    speechThresholdMeter: import_zod11.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_zod11.z.array(import_zod11.z.object({
+    handle: import_zod11.z.string(),
+    is_current_device: import_zod11.z.boolean(),
+    is_default: import_zod11.z.boolean(),
+    is_effective_device: import_zod11.z.boolean(),
+    name: import_zod11.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_zod11.z.array(import_zod11.z.object({
+    handle: import_zod11.z.string(),
+    is_current_device: import_zod11.z.boolean(),
+    is_default: import_zod11.z.boolean(),
+    is_effective_device: import_zod11.z.boolean(),
+    name: import_zod11.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_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,
+  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() }
-};
-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/party.ts
+var import_valorant_api_types2 = require("valorant-api-types");
+var party = {
+  get: import_valorant_api_types2.endpoints.partyEndpoint,
+  player: import_valorant_api_types2.endpoints.partyPlayerEndpoint,
+  removePlayer: import_valorant_api_types2.endpoints.partyRemovePlayerEndpoint,
+  setMemberReady: import_valorant_api_types2.endpoints.partySetMemberReadyEndpoint,
+  refreshCompetitiveTier: import_valorant_api_types2.endpoints.refreshCompetitiveTierEndpoint,
+  refreshPlayerIdentity: import_valorant_api_types2.endpoints.refreshPlayerIdentityEndpoint,
+  refreshPings: import_valorant_api_types2.endpoints.refreshPingsEndpoint,
+  changeQueue: import_valorant_api_types2.endpoints.changeQueueEndpoint,
+  startCustomGame: import_valorant_api_types2.endpoints.startCustomGameEndpoint,
+  enterMatchmakingQueue: import_valorant_api_types2.endpoints.enterMatchmakingQueueEndpoint,
+  leaveMatchmakingQueue: import_valorant_api_types2.endpoints.leaveMatchmakingQueueEndpoint,
+  setAccessibility: import_valorant_api_types2.endpoints.setPartyAccessibilityEndpoint,
+  setCustomGameSettings: import_valorant_api_types2.endpoints.setCustomGameSettingsEndpoint,
+  invite: import_valorant_api_types2.endpoints.partyInviteEndpoint,
+  requestToJoin: import_valorant_api_types2.endpoints.partyRequestEndpoint,
+  declineRequest: import_valorant_api_types2.endpoints.partyDeclineEndpoint,
+  customGameConfigs: import_valorant_api_types2.endpoints.customGameConfigsEndpoint,
+  chatToken: import_valorant_api_types2.endpoints.partyChatTokenEndpoint,
+  voiceToken: import_valorant_api_types2.endpoints.partyVoiceTokenEndpoint,
+  disableCode: import_valorant_api_types2.endpoints.partyDisableCodeEndpoint,
+  generateCode: import_valorant_api_types2.endpoints.partyGenerateCodeEndpoint,
+  joinByCode: import_valorant_api_types2.endpoints.partyJoinByCodeEndpoint
+};
+
+// src/api/groups/store.ts
+var import_valorant_api_types3 = require("valorant-api-types");
+var store = {
+  prices: import_valorant_api_types3.endpoints.pricesEndpoint,
+  storefront: import_valorant_api_types3.endpoints.storefrontEndpoint,
+  wallet: import_valorant_api_types3.endpoints.walletEndpoint,
+  ownedItems: import_valorant_api_types3.endpoints.ownedItemsEndpoint,
+  storefrontV3: storefrontV3Endpoint,
+  agentStore: agentStoreEndpoint,
+  allEntitlements: allEntitlementsEndpoint
+};
+
+// src/api/groups/pregame.ts
+var import_valorant_api_types4 = require("valorant-api-types");
+var pregame = {
+  player: import_valorant_api_types4.endpoints.pregamePlayerEndpoint,
+  match: import_valorant_api_types4.endpoints.pregameMatchEndpoint,
+  loadouts: import_valorant_api_types4.endpoints.pregameLoadoutsEndpoint,
+  selectCharacter: import_valorant_api_types4.endpoints.selectCharacterEndpoint,
+  lockCharacter: import_valorant_api_types4.endpoints.lockCharacterEndpoint,
+  quit: import_valorant_api_types4.endpoints.pregameQuitEndpoint
+};
+
+// src/api/groups/currentGame.ts
+var import_valorant_api_types5 = require("valorant-api-types");
+var currentGame = {
+  player: import_valorant_api_types5.endpoints.currentGamePlayerEndpoint,
+  match: import_valorant_api_types5.endpoints.currentGameMatchEndpoint,
+  loadouts: import_valorant_api_types5.endpoints.currentGameLoadoutsEndpoint,
+  quit: import_valorant_api_types5.endpoints.currentGameQuitEndpoint
+};
+
+// src/api/groups/contracts.ts
+var import_valorant_api_types6 = require("valorant-api-types");
+var contracts = {
+  itemUpgrades: import_valorant_api_types6.endpoints.itemUpgradesEndpoint,
+  list: import_valorant_api_types6.endpoints.contractsEndpoint,
+  activate: import_valorant_api_types6.endpoints.activateContractEndpoint,
+  activeRecruitmentEvent: activeRecruitmentEventEndpoint
+};
+
+// src/api/groups/local.ts
+var import_valorant_api_types7 = require("valorant-api-types");
+var local = {
+  help: import_valorant_api_types7.endpoints.localHelpEndpoint,
+  sessions: import_valorant_api_types7.endpoints.sessionsEndpoint,
+  rsoUserInfo: import_valorant_api_types7.endpoints.rsoUserInfoEndpoint,
+  clientRegion: import_valorant_api_types7.endpoints.clientRegionEndpoint,
+  accountAlias: import_valorant_api_types7.endpoints.accountAliasEndpoint,
+  entitlementsToken: import_valorant_api_types7.endpoints.entitlementsTokenEndpoint,
+  chatSession: import_valorant_api_types7.endpoints.chatSessionEndpoint,
+  friends: import_valorant_api_types7.endpoints.friendsEndpoint,
+  sendFriendRequest: import_valorant_api_types7.endpoints.sendFriendRequestEndpoint,
+  removeFriendRequest: import_valorant_api_types7.endpoints.removeFriendRequestEndpoint,
+  presence: import_valorant_api_types7.endpoints.presenceEndpoint,
+  friendRequests: import_valorant_api_types7.endpoints.friendRequestsEndpoint,
+  swaggerDocs: import_valorant_api_types7.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_types8 = require("valorant-api-types");
+var chat = {
+  partyInfo: import_valorant_api_types8.endpoints.partyChatInfoEndpoint,
+  pregameInfo: import_valorant_api_types8.endpoints.pregameChatInfoEndpoint,
+  currentGameInfo: import_valorant_api_types8.endpoints.currentGameChatInfoEndpoint,
+  allInfo: import_valorant_api_types8.endpoints.allChatInfoEndpoint,
+  participants: import_valorant_api_types8.endpoints.chatParticipantsEndpoint,
+  send: import_valorant_api_types8.endpoints.sendChatEndpoint,
+  history: import_valorant_api_types8.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/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/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_types9 = require("valorant-api-types");
+var auth = {
+  cookies: import_valorant_api_types9.endpoints.authCookiesEndpoint,
+  request: import_valorant_api_types9.endpoints.authRequestEndpoint,
+  multiFactor: import_valorant_api_types9.endpoints.multiFactorAuthenticationEndpoint,
+  cookieReauth: import_valorant_api_types9.endpoints.cookieReauthEndpoint,
+  entitlement: import_valorant_api_types9.endpoints.entitlementEndpoint,
+  playerInfo: import_valorant_api_types9.endpoints.playerInfoEndpoint,
+  riotGeo: import_valorant_api_types9.endpoints.riotGeoEndpoint,
+  pasToken: import_valorant_api_types9.endpoints.pasTokenEndpoint,
+  riotClientConfig: import_valorant_api_types9.endpoints.riotClientConfigEndpoint
+};
+
+// src/endpoints/catalog/index.ts
+var import_zod14 = require("zod");
+
+// src/endpoints/catalog/factory.ts
+var import_zod12 = 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_zod12.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_zod12.z.array(schema), queryParams),
+    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
+  };
+}
+
+// src/endpoints/catalog/schemas.ts
+var import_zod13 = require("zod");
+var text = import_zod13.z.string().nullish();
+var asset = import_zod13.z.object({
+  uuid: import_zod13.z.string(),
+  displayName: text,
+  displayIcon: text,
+  assetPath: text
+}).passthrough();
+var agentSchema = asset.extend({
+  description: text,
+  developerName: text,
+  characterTags: import_zod13.z.array(import_zod13.z.string()).nullish(),
+  displayIconSmall: text,
+  bustPortrait: text,
+  fullPortrait: text,
+  killfeedPortrait: text,
+  background: text,
+  isPlayableCharacter: import_zod13.z.boolean(),
+  role: import_zod13.z.object({ uuid: import_zod13.z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: import_zod13.z.array(import_zod13.z.object({ slot: import_zod13.z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+});
+var mapSchema = asset.extend({
+  coordinates: text,
+  listViewIcon: text,
+  splash: text,
+  mapUrl: text,
+  xMultiplier: import_zod13.z.number(),
+  yMultiplier: import_zod13.z.number(),
+  xScalarToAdd: import_zod13.z.number(),
+  yScalarToAdd: import_zod13.z.number(),
+  callouts: import_zod13.z.array(import_zod13.z.object({ regionName: import_zod13.z.string(), superRegionName: import_zod13.z.string(), location: import_zod13.z.object({ x: import_zod13.z.number(), y: import_zod13.z.number() }) }).passthrough()).nullish()
+});
+var weaponSchema = asset.extend({
+  category: import_zod13.z.string(),
+  defaultSkinUuid: import_zod13.z.string(),
+  killStreamIcon: text,
+  weaponStats: import_zod13.z.object({}).passthrough().nullish(),
+  shopData: import_zod13.z.object({}).passthrough().nullish(),
+  skins: import_zod13.z.array(import_zod13.z.object({}).passthrough())
+});
+var skinSchema = asset.extend({
+  themeUuid: import_zod13.z.string(),
+  contentTierUuid: text,
+  wallpaper: text,
+  chromas: import_zod13.z.array(asset.passthrough()),
+  levels: import_zod13.z.array(asset.passthrough())
+});
+var seasonSchema = import_zod13.z.object({
+  uuid: import_zod13.z.string(),
+  displayName: text,
+  type: text,
+  startTime: import_zod13.z.string(),
+  endTime: import_zod13.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_zod13.z.object({
+  manifestId: import_zod13.z.string(),
+  branch: import_zod13.z.string(),
+  version: import_zod13.z.string(),
+  buildVersion: import_zod13.z.string(),
+  engineVersion: import_zod13.z.string(),
+  riotClientVersion: import_zod13.z.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: import_zod13.z.string(),
+  buildDate: import_zod13.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_zod14.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_zod14.z.object({ uuid: import_zod14.z.string(), tiers: import_zod14.z.array(import_zod14.z.object({ tier: import_zod14.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_zod14.z.object({ uuid: import_zod14.z.string(), displayName: text }).passthrough());
+var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", import_zod14.z.object({ uuid: import_zod14.z.string(), displayName: text, titleText: text }).passthrough());
+var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", import_zod14.z.object({ uuid: import_zod14.z.string(), seasonUuid: import_zod14.z.string(), startTime: import_zod14.z.string(), endTime: import_zod14.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_types10 = require("valorant-api-types");
 
 // src/errors.ts
 var ValorantError = class extends Error {
@@ -948,7 +2063,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_types10.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);
@@ -1139,6 +2254,83 @@ var localTransport = async (request) => {
   });
 };
 
+// src/internal/body.ts
+var import_zod15 = 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_zod15.ZodError) return { success: false, error: thrown };
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return { success: false, error: new import_zod15.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/local.ts
 function parseLockfile(content) {
   const [name, pid, port, password, protocol] = content.trim().split(":");
@@ -1223,7 +2415,7 @@ async function openEventStream(ctx) {
 }
 
 // src/request.ts
-var import_valorant_api_types3 = require("valorant-api-types");
+var import_valorant_api_types11 = require("valorant-api-types");
 
 // src/types.ts
 function paramName(variable) {
@@ -1250,11 +2442,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_types11.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_types11.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_types11.typeToPrefix)({ type: "local", port: ctx.require("localPort") });
     case "other":
       return "";
   }
@@ -1304,8 +2496,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;
@@ -1334,13 +2524,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 +2539,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;
@@ -1387,17 +2577,6 @@ 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)];
@@ -1411,15 +2590,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,46 +2597,6 @@ 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/index.ts
 __reExport(index_exports, require("valorant-api-types"), module.exports);