@voxary/valorant-client 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,771 +1,1886 @@
-// src/client.ts
-import { ZodError } from "zod";
-
-// src/api/registry.ts
+// src/api/groups/pvp.ts
 import { endpoints as e } from "valorant-api-types";
 
-// src/extra/catalog.ts
+// src/endpoints/riot/account.ts
 import { z } from "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 = z.string().nullish();
-var asset = z.object({
-  uuid: z.string(),
-  displayName: text,
-  displayIcon: text,
-  assetPath: text
-}).passthrough();
-var agentSchema = asset.extend({
-  description: text,
-  developerName: text,
-  characterTags: z.array(z.string()).nullish(),
-  displayIconSmall: text,
-  bustPortrait: text,
-  fullPortrait: text,
-  killfeedPortrait: text,
-  background: text,
-  isPlayableCharacter: z.boolean(),
-  role: z.object({ uuid: z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
-  abilities: z.array(z.object({ slot: z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
-});
-var mapSchema = asset.extend({
-  coordinates: text,
-  listViewIcon: text,
-  splash: text,
-  mapUrl: text,
-  xMultiplier: z.number(),
-  yMultiplier: z.number(),
-  xScalarToAdd: z.number(),
-  yScalarToAdd: z.number(),
-  callouts: z.array(z.object({ regionName: z.string(), superRegionName: z.string(), location: z.object({ x: z.number(), y: z.number() }) }).passthrough()).nullish()
-});
-var weaponSchema = asset.extend({
-  category: z.string(),
-  defaultSkinUuid: z.string(),
-  killStreamIcon: text,
-  weaponStats: z.object({}).passthrough().nullish(),
-  shopData: z.object({}).passthrough().nullish(),
-  skins: z.array(z.object({}).passthrough())
-});
-var skinSchema = asset.extend({
-  themeUuid: z.string(),
-  contentTierUuid: text,
-  wallpaper: text,
-  chromas: z.array(asset.passthrough()),
-  levels: z.array(asset.passthrough())
-});
-var seasonSchema = z.object({
-  uuid: z.string(),
-  displayName: text,
-  type: text,
-  startTime: z.string(),
-  endTime: z.string(),
-  parentUuid: text,
-  assetPath: text
-}).passthrough();
-var versionSchema = z.object({
-  manifestId: z.string(),
-  branch: z.string(),
-  version: z.string(),
-  buildVersion: z.string(),
-  engineVersion: z.string(),
-  riotClientVersion: z.string().describe("Value of the X-Riot-ClientVersion header"),
-  riotClientBuild: z.string(),
-  buildDate: z.string()
-}).passthrough();
-function query(extra = []) {
-  return new Map([
-    ["language", 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, z.array(schema), extra),
-    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
-  };
-}
-var playable = [["isPlayableCharacter", 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", z.object({ uuid: z.string(), tiers: z.array(z.object({ tier: 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", z.object({ uuid: z.string(), displayName: text }).passthrough());
-var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
-var playerTitles = collection("Player Titles", "Player Title", "playertitles", z.object({ uuid: z.string(), displayName: text, titleText: text }).passthrough());
-var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
-var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", z.object({ uuid: z.string(), seasonUuid: z.string(), startTime: z.string(), endTime: 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": z.object({
+    Version: z.number(),
+    DailyRewards: z.object({
+      RemainingLifetimeSeconds: z.number(),
+      BonusMilestonesPending: z.number(),
+      Milestones: z.array(z.object({
+        Progress: z.number(),
+        BonusApplied: z.boolean()
+      }))
+    }),
+    ProcessedMatches: z.array(z.object({
+      ID: z.string(),
+      CreatedAt: z.string(),
+      DailyExpireTime: z.string(),
+      PreviousDailyExpireTime: z.string(),
+      ProgressBefore: z.number(),
+      ProgressAfter: z.number(),
+      XP: z.number(),
+      SoftCurrency: z.number(),
+      WasPenalized: z.boolean(),
+      BonusesApplied: z.number(),
+      DailyBonusState: z.array(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": z.object({
+    default: z.object({
+      flatProgressPerMatch: z.number(),
+      progressPerRoundWin: z.boolean()
+    }),
+    queueOverrides: z.object({
+      abilitydraftarena: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      competitive: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_abilitydraftarena: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_competitive: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_dodgeball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_fortcollins: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_hurm: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_newmap: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_skirmish2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_skirmishascension1v1: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_skirmishascension2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_snowball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_spikerush: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_swiftplay: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_unrated: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      console_valaram: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      dodgeball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      fortcollins: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      ggteam: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      hurm: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      newmap: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      premier: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      skirmish2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      skirmishascension1v1: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      skirmishascension2v2: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      snowball: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      spikerush: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      swiftplay: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      unrated: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: z.boolean()
+      }),
+      valaram: z.object({
+        flatProgressPerMatch: z.number(),
+        progressPerRoundWin: 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": z.object({
+    Subject: z.string(),
+    FavoritedContent: z.record(z.string(), z.object({
+      FavoriteID: z.string(),
+      ItemID: 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": z.array(z.object({
+    id: z.string(),
+    tempT: 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": z.object({
+    puuid: z.string(),
+    version: z.number(),
+    tempS: z.object({
+      "00000000-0000-0000-0000-000000000000": z.object({
+        tempS: z.string(),
+        tempA: z.record(z.string(), z.object({
+          id: z.string(),
+          tempC: z.number(),
+          tempB: z.number()
+        }))
+      }),
+      "8102cd81-43a0-d0d7-bd59-47b8fe9bed1b": z.object({
+        tempS: z.string(),
+        tempA: z.record(z.string(), z.object({
+          id: z.string(),
+          tempC: z.number(),
+          tempB: z.number()
+        }))
+      })
+    }),
+    tempM: z.array(z.object({
+      id: z.string(),
+      tempG: z.number(),
+      tempP: z.record(z.string(), z.object({
+        tempA: z.record(z.string(), z.object({
+          id: z.string(),
+          tempV: z.number(),
+          tempB: 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": z.object({
+    ProcessedQueues: z.array(z.string()),
+    PerformanceScoreQueues: z.array(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": z.object({
+    Subject: z.string(),
+    Bonsais: z.array(z.object({
+      BonsaiID: z.string(),
+      HypeID: z.string().optional(),
+      BackgroundID: z.string().optional(),
+      ClipID: z.string().optional(),
+      BorderID: z.string().optional(),
+      Flourish: z.object({
+        ShortLevel: z.number().optional(),
+        PreviousShortLevel: z.number().optional(),
+        LongLevel: z.number().optional(),
+        FlourishID: z.string().optional(),
+        Points: z.number().optional(),
+        PointsVersion: z.number().optional()
+      }),
+      TrackProgressList: z.array(z.object({
+        TrackID: z.string(),
+        TrackLevel: z.number().optional()
+      }))
+    })),
+    LongGroupVersion: z.number()
+  }) }
 };
 
-// src/extra/riot.ts
+// src/endpoints/riot/chat.ts
 import { z as z2 } from "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": z2.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": z2.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": z2.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": z2.unknown() }
+  responses: { "200": z2.object({
+    bounceDockIconEnabled: z2.boolean(),
+    "chat-status-message": z2.string(),
+    chatFilterDisabled: z2.boolean(),
+    chatGBG: z2.boolean(),
+    chatGroupDiscord: z2.boolean(),
+    chatGroupMobile: z2.boolean(),
+    chatGroupOffline: z2.boolean(),
+    chatWindow: z2.object({
+      detached: z2.boolean(),
+      height: z2.number(),
+      left: z2.number(),
+      top: z2.number(),
+      width: z2.number()
+    }),
+    chatWindowDockedHeight: z2.number(),
+    "closed-conversations": z2.object({
+      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": z2.number()
+    }),
+    friendRequestToastsDisabled: z2.boolean(),
+    "hidden-conversations": z2.object({}),
+    linkClickWarningEnabled: z2.boolean(),
+    messageNotificationsEnabled: z2.boolean(),
+    moreUnreadsEnabled: z2.boolean(),
+    "muted-conversations": z2.object({}),
+    recentlyPlayedFirstOpen: z2.boolean(),
+    recentlyPlayedOpen: z2.boolean(),
+    "roster-group-collapsed": z2.object({}),
+    showWhenTypingEnabled: z2.boolean(),
+    sortBy: z2.string(),
+    usePlayerPreferences: z2.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": z2.unknown() }
+  responses: { "200": z2.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": z2.unknown() }
+
+// src/endpoints/riot/contracts.ts
+import { z as z3 } from "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": z3.object({
+    AgentID: z3.string(),
+    CounterID: z3.string(),
+    MilestoneThreshold: z3.number(),
+    StartDate: z3.string(),
+    EndDate: z3.string(),
+    IsActive: z3.boolean(),
+    includedPlatforms: z3.object({
+      console: z3.object({
+        developmentOnly: z3.boolean()
+      }),
+      mobile: z3.object({
+        developmentOnly: z3.boolean()
+      }),
+      pc: z3.object({
+        developmentOnly: z3.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": z2.unknown() }
+
+// src/endpoints/riot/esports.ts
+import { z as z4 } from "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": z4.object({
+    Tournaments: z4.array(z4.object({
+      ID: z4.string(),
+      StartTimeUTC: z4.string(),
+      EndTimeUTC: z4.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": z2.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": z4.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": z2.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": z4.object({
+    PickemLeagues: z4.array(z4.object({
+      LeagueID: z4.string(),
+      EldsLeagueID: z4.string(),
+      Tournament: z4.object({
+        ID: z4.string(),
+        EldsTournamentID: z4.string(),
+        LeagueID: z4.string(),
+        PickBlocks: z4.array(z4.object({
+          ID: z4.string(),
+          EldsTournamentID: z4.string(),
+          Slug: z4.object({
+            Slug: z4.string()
+          }),
+          PickOpenTime: z4.string(),
+          PickCloseTime: z4.string(),
+          State: z4.string(),
+          OpenLevel: z4.string(),
+          BlockType: z4.string(),
+          PickBlockElements: z4.array(z4.object({
+            ID: z4.string(),
+            PickBlockID: z4.string(),
+            Section: z4.object({
+              ID: z4.string(),
+              EldsSectionID: z4.string(),
+              CorrectPick: z4.object({
+                Entries: z4.array(z4.object({
+                  Index: z4.number(),
+                  Correctness: z4.string(),
+                  ParticipantID: z4.string(),
+                  Points: z4.number(),
+                  Rank: z4.number()
+                })).nullable()
+              })
+            }),
+            Match: z4.object({
+              ID: z4.string(),
+              EldsMatchID: z4.string(),
+              BaselinePoints: z4.number(),
+              CorrectPick: z4.string(),
+              ResultState: z4.string()
+            }),
+            PickOpenTime: z4.string(),
+            PickCloseTime: z4.string(),
+            State: z4.string(),
+            DisplayOrder: z4.number()
+          })),
+          CompletionStatus: z4.string()
+        })),
+        Participants: z4.array(z4.object({
+          ID: z4.string(),
+          EldsTeamID: z4.string()
+        }))
+      }),
+      Published: z4.boolean()
+    }))
+  }) }
 };
+
+// src/endpoints/riot/local.ts
+import { z as z5 } from "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": z2.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": z2.unknown() }
+  responses: { "200": z5.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": z2.unknown() }
+  responses: { "200": z5.array(z5.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": z2.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": z2.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": z2.unknown() }
+  responses: { "200": z5.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": z2.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": z2.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": z2.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": z2.unknown() }
+  responses: { "200": z5.object({
+    clientId: z5.string(),
+    expiry: z5.number(),
+    scopes: z5.array(z5.string()),
+    token: z5.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": z2.unknown() }
+  responses: { "200": z5.object({
+    state: z5.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": z2.unknown() }
+  responses: { "200": z5.object({
+    state: z5.string(),
+    token: z5.string(),
+    tokenType: z5.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": z2.unknown() }
+  responses: { "200": z5.object({
+    pid: z5.number(),
+    status: z5.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": z2.unknown() }
+  responses: { "200": z5.string() }
+};
+var localEulaEndpoint = {
+  name: "Eula",
+  description: "Get the EULA",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/agreement/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": z5.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": z5.string() }
+};
+
+// src/endpoints/riot/premier.ts
+import { z as z6 } from "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": z6.object({
+    PremierSeasons: z6.array(z6.object({
+      ID: z6.string(),
+      Name: z6.string(),
+      PreviousPremierSeasonID: z6.string(),
+      NextPremierSeasonID: z6.string(),
+      IsActive: z6.boolean(),
+      StartTime: z6.string(),
+      EndTime: z6.string(),
+      Events: z6.array(z6.object({
+        ID: z6.string(),
+        Type: z6.string(),
+        StartDateTime: z6.string(),
+        EndDateTime: z6.string(),
+        MapSelectionStrategy: z6.string(),
+        MapPoolMapIDs: z6.array(z6.string()),
+        PointsRequiredToParticipate: z6.number()
+      })),
+      ScheduledEvents: z6.array(z6.object({
+        EventID: z6.string(),
+        EventType: z6.string(),
+        Conference: z6.string(),
+        DivisionGroup: z6.string(),
+        EventPresetName: z6.string(),
+        StartDateTime: z6.string(),
+        EndDateTime: z6.string(),
+        TournamentRoundTimes: z6.array(z6.object({
+          StartDateTime: z6.string(),
+          EndDateTime: z6.string()
+        }))
+      })),
+      Conferences: z6.array(z6.object({
+        id: z6.string(),
+        key: z6.string(),
+        isSuper: z6.boolean(),
+        gamePods: z6.array(z6.string()),
+        timezone: z6.string(),
+        superConference: z6.string().optional(),
+        leaderboardPlayoffQualificationDateTime: z6.string(),
+        leaderboardPromotionFinalizationDateTime: z6.string()
+      })),
+      Divisions: z6.array(z6.object({
+        Division: z6.number(),
+        DivisionName: z6.string(),
+        DivisionGroup: z6.string(),
+        EventPresetName: z6.string()
+      })),
+      DivisionThresholds: z6.array(z6.object({
+        playoffThresholdType: z6.string(),
+        playoffThresholdValue: z6.number(),
+        promotionThresholdType: z6.string(),
+        promotionThresholdValue: z6.number(),
+        shouldPromoteToSuperConference: z6.boolean(),
+        skipReseedCriteria: z6.string(),
+        conference: z6.string().optional(),
+        division: z6.number().optional(),
+        promotionConference: z6.string().optional(),
+        skipReseedCriteriaValue: z6.number().optional()
+      })),
+      EventPresets: z6.object({
+        PRO: z6.object({
+          EventPresetsByEventType: z6.object({
+            LEAGUE: z6.object({
+              EventPresetName: z6.string(),
+              eventType: z6.string(),
+              bestOfN: z6.number(),
+              matchmakingStrategy: z6.string(),
+              queueID: z6.string(),
+              pointsConfig: z6.object({
+                PointsForWin: z6.number(),
+                PointsForLoss: z6.number()
+              })
+            }),
+            SCRIM: z6.object({
+              EventPresetName: z6.string(),
+              eventType: z6.string(),
+              bestOfN: z6.number(),
+              matchmakingStrategy: z6.string(),
+              queueID: z6.string(),
+              pointsConfig: z6.object({
+                PointsForWin: z6.number(),
+                PointsForLoss: z6.number()
+              })
+            }),
+            TOURNAMENT: z6.object({
+              EventPresetName: z6.string(),
+              eventType: z6.string(),
+              bestOfN: z6.number(),
+              matchmakingStrategy: z6.string(),
+              queueID: z6.string(),
+              pointsConfig: z6.object({
+                PointsForWin: z6.number(),
+                PointsForLoss: z6.number()
+              })
+            })
+          })
+        }),
+        REGULAR: z6.object({
+          EventPresetsByEventType: z6.object({
+            LEAGUE: z6.object({
+              EventPresetName: z6.string(),
+              eventType: z6.string(),
+              bestOfN: z6.number(),
+              matchmakingStrategy: z6.string(),
+              queueID: z6.string(),
+              pointsConfig: z6.object({
+                PointsForWin: z6.number(),
+                PointsForLoss: z6.number()
+              })
+            }),
+            SCRIM: z6.object({
+              EventPresetName: z6.string(),
+              eventType: z6.string(),
+              bestOfN: z6.number(),
+              matchmakingStrategy: z6.string(),
+              queueID: z6.string(),
+              pointsConfig: z6.object({
+                PointsForWin: z6.number(),
+                PointsForLoss: z6.number()
+              })
+            }),
+            TOURNAMENT: z6.object({
+              EventPresetName: z6.string(),
+              eventType: z6.string(),
+              bestOfN: z6.number(),
+              matchmakingStrategy: z6.string(),
+              queueID: z6.string(),
+              pointsConfig: z6.object({
+                PointsForWin: z6.number(),
+                PointsForLoss: z6.number()
+              })
+            })
+          })
+        })
+      }),
+      FlawlessPointRequirement: z6.number(),
+      ChampionshipPointRequirement: z6.number(),
+      ChampionshipEventID: z6.string(),
+      EnrollmentPhaseStartDateTime: z6.string(),
+      EnrollmentPhaseEndDateTime: z6.string(),
+      LeaderboardPlayoffQualificationDateTime: z6.string(),
+      LeaderboardPromotionFinalizationDateTime: z6.string(),
+      LeaderboardFinalizationDateTime: z6.string(),
+      ContenderEligibilityExpiryDateTime: z6.string(),
+      StageLockTime: z6.string(),
+      ParticipationRewardsActIDs: z6.array(z6.string()),
+      ParticipationRewards: z6.object({
+        EntitlementRewards: z6.array(z6.object({
+          ItemTypeID: z6.string(),
+          ItemID: z6.string(),
+          Amount: z6.number()
+        }))
+      }),
+      TournamentWinnerRewards: z6.object({}),
+      DivisionWinnerRewards: z6.object({
+        ADVANCED: z6.object({
+          EntitlementRewards: z6.array(z6.object({
+            ItemTypeID: z6.string(),
+            ItemID: z6.string(),
+            Amount: z6.number()
+          }))
+        }).optional(),
+        CONTENDER: z6.object({
+          EntitlementRewards: z6.array(z6.object({
+            ItemTypeID: z6.string(),
+            ItemID: z6.string(),
+            Amount: z6.number()
+          }))
+        }).optional(),
+        ELITE: z6.object({
+          EntitlementRewards: z6.array(z6.object({
+            ItemTypeID: z6.string(),
+            ItemID: z6.string(),
+            Amount: z6.number()
+          }))
+        }).optional(),
+        INTERMEDIATE: z6.object({
+          EntitlementRewards: z6.array(z6.object({
+            ItemTypeID: z6.string(),
+            ItemID: z6.string(),
+            Amount: z6.number()
+          }))
+        }).optional(),
+        OPEN: z6.object({
+          EntitlementRewards: z6.array(z6.object({
+            ItemTypeID: z6.string(),
+            ItemID: z6.string(),
+            Amount: z6.number()
+          }))
+        }).optional(),
+        INVITE: z6.object({
+          EntitlementRewards: z6.array(z6.object({
+            ItemTypeID: z6.string(),
+            ItemID: z6.string(),
+            Amount: z6.number()
+          }))
+        }).optional()
+      }),
+      RosterRecentActivityNumSeasons: z6.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": z6.object({
+    ID: z6.string(),
+    Name: z6.string(),
+    PreviousPremierSeasonID: z6.string(),
+    NextPremierSeasonID: z6.string(),
+    IsActive: z6.boolean(),
+    StartTime: z6.string(),
+    EndTime: z6.string(),
+    Events: z6.array(z6.object({
+      ID: z6.string(),
+      Type: z6.string(),
+      StartDateTime: z6.string(),
+      EndDateTime: z6.string(),
+      MapSelectionStrategy: z6.string(),
+      MapPoolMapIDs: z6.array(z6.string()),
+      PointsRequiredToParticipate: z6.number()
+    })),
+    ScheduledEvents: z6.array(z6.object({
+      EventID: z6.string(),
+      EventType: z6.string(),
+      Conference: z6.string(),
+      DivisionGroup: z6.string(),
+      EventPresetName: z6.string(),
+      StartDateTime: z6.string(),
+      EndDateTime: z6.string(),
+      TournamentRoundTimes: z6.array(z6.object({
+        StartDateTime: z6.string(),
+        EndDateTime: z6.string()
+      }))
+    })),
+    Conferences: z6.array(z6.object({
+      id: z6.string(),
+      key: z6.string(),
+      isSuper: z6.boolean(),
+      gamePods: z6.array(z6.string()),
+      timezone: z6.string(),
+      superConference: z6.string().optional(),
+      leaderboardPlayoffQualificationDateTime: z6.string(),
+      leaderboardPromotionFinalizationDateTime: z6.string()
+    })),
+    Divisions: z6.array(z6.object({
+      Division: z6.number(),
+      DivisionName: z6.string(),
+      DivisionGroup: z6.string(),
+      EventPresetName: z6.string()
+    })),
+    DivisionThresholds: z6.array(z6.object({
+      playoffThresholdType: z6.string(),
+      playoffThresholdValue: z6.number(),
+      promotionThresholdType: z6.string(),
+      promotionThresholdValue: z6.number(),
+      shouldPromoteToSuperConference: z6.boolean(),
+      skipReseedCriteria: z6.string(),
+      conference: z6.string().optional(),
+      division: z6.number().optional(),
+      promotionConference: z6.string().optional(),
+      skipReseedCriteriaValue: z6.number().optional()
+    })),
+    EventPresets: z6.object({
+      PRO: z6.object({
+        EventPresetsByEventType: z6.object({
+          LEAGUE: z6.object({
+            EventPresetName: z6.string(),
+            eventType: z6.string(),
+            bestOfN: z6.number(),
+            matchmakingStrategy: z6.string(),
+            queueID: z6.string(),
+            pointsConfig: z6.object({
+              PointsForWin: z6.number(),
+              PointsForLoss: z6.number()
+            })
+          }),
+          SCRIM: z6.object({
+            EventPresetName: z6.string(),
+            eventType: z6.string(),
+            bestOfN: z6.number(),
+            matchmakingStrategy: z6.string(),
+            queueID: z6.string(),
+            pointsConfig: z6.object({
+              PointsForWin: z6.number(),
+              PointsForLoss: z6.number()
+            })
+          }),
+          TOURNAMENT: z6.object({
+            EventPresetName: z6.string(),
+            eventType: z6.string(),
+            bestOfN: z6.number(),
+            matchmakingStrategy: z6.string(),
+            queueID: z6.string(),
+            pointsConfig: z6.object({
+              PointsForWin: z6.number(),
+              PointsForLoss: z6.number()
+            })
+          })
+        })
+      }),
+      REGULAR: z6.object({
+        EventPresetsByEventType: z6.object({
+          LEAGUE: z6.object({
+            EventPresetName: z6.string(),
+            eventType: z6.string(),
+            bestOfN: z6.number(),
+            matchmakingStrategy: z6.string(),
+            queueID: z6.string(),
+            pointsConfig: z6.object({
+              PointsForWin: z6.number(),
+              PointsForLoss: z6.number()
+            })
+          }),
+          SCRIM: z6.object({
+            EventPresetName: z6.string(),
+            eventType: z6.string(),
+            bestOfN: z6.number(),
+            matchmakingStrategy: z6.string(),
+            queueID: z6.string(),
+            pointsConfig: z6.object({
+              PointsForWin: z6.number(),
+              PointsForLoss: z6.number()
+            })
+          }),
+          TOURNAMENT: z6.object({
+            EventPresetName: z6.string(),
+            eventType: z6.string(),
+            bestOfN: z6.number(),
+            matchmakingStrategy: z6.string(),
+            queueID: z6.string(),
+            pointsConfig: z6.object({
+              PointsForWin: z6.number(),
+              PointsForLoss: z6.number()
+            })
+          })
+        })
+      })
+    }),
+    FlawlessPointRequirement: z6.number(),
+    ChampionshipPointRequirement: z6.number(),
+    ChampionshipEventID: z6.string(),
+    EnrollmentPhaseStartDateTime: z6.string(),
+    EnrollmentPhaseEndDateTime: z6.string(),
+    LeaderboardPlayoffQualificationDateTime: z6.string(),
+    LeaderboardPromotionFinalizationDateTime: z6.string(),
+    LeaderboardFinalizationDateTime: z6.string(),
+    ContenderEligibilityExpiryDateTime: z6.string(),
+    StageLockTime: z6.string(),
+    ParticipationRewards: z6.object({}),
+    TournamentWinnerRewards: z6.object({}),
+    DivisionWinnerRewards: z6.object({}),
+    RosterRecentActivityNumSeasons: z6.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": z6.object({
+    PremierConferences: z6.array(z6.object({
+      id: z6.string(),
+      key: z6.string(),
+      isSuper: z6.boolean(),
+      gamePods: z6.array(z6.string()),
+      timezone: z6.string(),
+      superConference: z6.string().optional(),
+      leaderboardPlayoffQualificationDateTime: z6.string(),
+      leaderboardPromotionFinalizationDateTime: z6.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": z6.object({
+    leagueMatchLimit: z6.number(),
+    tournamentLimit: z6.number(),
+    timeUntilNextResetSeconds: z6.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": z6.object({
+    subject: z6.string(),
+    accountVerificationStatus: z6.boolean(),
+    rankedPlacementCompletionStatus: z6.boolean(),
+    matchLimitReached: z6.boolean(),
+    isOnProvidedRoster: z6.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": z6.object({
+    puuid: z6.string(),
+    rosterId: z6.string(),
+    version: z6.number(),
+    createdAt: z6.number(),
+    updatedAt: z6.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": z6.object({
+    puuid: z6.string(),
+    rosterId: z6.string(),
+    prestige: z6.object({
+      earnedPrestige: z6.boolean(),
+      earnedAura: z6.boolean(),
+      showTag: z6.boolean(),
+      showPlating: z6.boolean(),
+      showAura: z6.boolean()
+    }),
+    contenderEligibilityExpiry: z6.string(),
+    socialVersion: z6.number(),
+    premierVersion: z6.number(),
+    updatedAt: z6.number(),
+    seasons: z6.object({
+      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": z6.object({
+        seasonId: z6.string(),
+        hasEarnedPrestigeAura: z6.boolean(),
+        hasEarnedParticipation: z6.boolean(),
+        hasEarnedDivisionWinner: z6.boolean()
+      }),
+      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": z6.object({
+        seasonId: z6.string(),
+        hasEarnedPrestigeAura: z6.boolean(),
+        hasEarnedParticipation: z6.boolean(),
+        hasEarnedDivisionWinner: z6.boolean()
+      })
+    })
+  }) }
+};
+
+// src/endpoints/riot/pvp.ts
+import { z as z7 } from "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": z7.object({
+    Subject: z7.string(),
+    Version: z7.number(),
+    Guns: z7.array(z7.object({
+      ID: z7.string(),
+      SkinID: z7.string(),
+      SkinLevelID: z7.string(),
+      ChromaID: z7.string(),
+      CharmInstanceID: z7.string().optional(),
+      CharmID: z7.string().optional(),
+      CharmLevelID: z7.string().optional()
+    })),
+    ActiveExpressions: z7.array(z7.object({
+      TypeID: z7.string(),
+      AssetID: z7.string()
+    })),
+    DynamicOptions: z7.object({}),
+    Identity: z7.object({
+      PlayerCardID: z7.string(),
+      PlayerTitleID: z7.string(),
+      AccountLevel: z7.number(),
+      PreferredLevelBorderID: z7.string(),
+      HideAccountLevel: z7.boolean()
+    }),
+    Incognito: z7.boolean()
+  }) }
+};
+
+// src/endpoints/riot/restrictions.ts
+import { z as z8 } from "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": z8.object({
+    Subject: z8.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": z8.object({
+    Subject: z8.string()
+  }) }
+};
+
+// src/endpoints/riot/store.ts
+import { z as z9 } from "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": z9.object({
+    AgentStore: z9.object({
+      AgentStoreOffers: z9.array(z9.object({
+        AgentID: z9.string(),
+        StoreOffers: z9.array(z9.object({
+          OfferID: z9.string(),
+          IsDirectPurchase: z9.boolean(),
+          StartDate: z9.string(),
+          Cost: z9.record(z9.string(), z9.number()),
+          Rewards: z9.array(z9.object({
+            ItemTypeID: z9.string(),
+            ItemID: z9.string(),
+            Quantity: z9.number()
+          }))
+        }))
+      })),
+      CurrentFeaturedAgent: z9.string(),
+      NextFeaturedAgent: z9.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": z9.object({
+    EntitlementsByTypes: z9.array(z9.object({
+      ItemTypeID: z9.string(),
+      Entitlements: z9.array(z9.object({
+        TypeID: z9.string(),
+        ItemID: z9.string(),
+        InstanceID: z9.string().optional()
+      }))
+    }))
+  }) }
+};
+
+// src/endpoints/riot/storefront.ts
+import { z as z10 } from "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": z10.object({
+    FeaturedBundle: z10.object({
+      Bundle: z10.object({
+        ID: z10.string(),
+        DataAssetID: z10.string(),
+        CurrencyID: z10.string(),
+        Items: z10.array(z10.object({
+          Item: z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }),
+          BasePrice: z10.number(),
+          CurrencyID: z10.string(),
+          DiscountPercent: z10.number(),
+          DiscountedPrice: z10.number(),
+          IsPromoItem: z10.boolean()
+        })),
+        ItemOffers: z10.array(z10.object({
+          BundleItemOfferID: z10.string(),
+          Offer: z10.object({
+            OfferID: z10.string(),
+            IsDirectPurchase: z10.boolean(),
+            StartDate: z10.string(),
+            Cost: z10.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+            }),
+            Rewards: z10.array(z10.object({
+              ItemTypeID: z10.string(),
+              ItemID: z10.string(),
+              Quantity: z10.number()
+            }))
+          }),
+          DiscountPercent: z10.number(),
+          DiscountedCost: z10.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+          })
+        })),
+        TotalBaseCost: z10.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+        }),
+        TotalDiscountedCost: z10.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+        }),
+        TotalDiscountPercent: z10.number(),
+        DurationRemainingInSeconds: z10.number(),
+        WholesaleOnly: z10.boolean(),
+        IsGiftable: z10.number()
+      }),
+      Bundles: z10.array(z10.object({
+        ID: z10.string(),
+        DataAssetID: z10.string(),
+        CurrencyID: z10.string(),
+        Items: z10.array(z10.object({
+          Item: z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Amount: z10.number()
+          }),
+          BasePrice: z10.number(),
+          CurrencyID: z10.string(),
+          DiscountPercent: z10.number(),
+          DiscountedPrice: z10.number(),
+          IsPromoItem: z10.boolean()
+        })),
+        ItemOffers: z10.array(z10.object({
+          BundleItemOfferID: z10.string(),
+          Offer: z10.object({
+            OfferID: z10.string(),
+            IsDirectPurchase: z10.boolean(),
+            StartDate: z10.string(),
+            Cost: z10.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+            }),
+            Rewards: z10.array(z10.object({
+              ItemTypeID: z10.string(),
+              ItemID: z10.string(),
+              Quantity: z10.number()
+            }))
+          }),
+          DiscountPercent: z10.number(),
+          DiscountedCost: z10.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+          })
+        })),
+        TotalBaseCost: z10.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+        }),
+        TotalDiscountedCost: z10.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+        }),
+        TotalDiscountPercent: z10.number(),
+        DurationRemainingInSeconds: z10.number(),
+        WholesaleOnly: z10.boolean(),
+        IsGiftable: z10.number()
+      })),
+      FeaturedTileEntries: z10.array(z10.object({
+        Type: z10.number(),
+        Entry: z10.object({
+          Bundle: z10.object({
+            ID: z10.string(),
+            DataAssetID: z10.string(),
+            CurrencyID: z10.string(),
+            Items: z10.array(z10.object({
+              Item: z10.object({
+                ItemTypeID: z10.string(),
+                ItemID: z10.string(),
+                Amount: z10.number()
+              }),
+              BasePrice: z10.number(),
+              CurrencyID: z10.string(),
+              DiscountPercent: z10.number(),
+              DiscountedPrice: z10.number(),
+              IsPromoItem: z10.boolean()
+            })),
+            ItemOffers: z10.array(z10.object({
+              BundleItemOfferID: z10.string(),
+              Offer: z10.object({
+                OfferID: z10.string(),
+                IsDirectPurchase: z10.boolean(),
+                StartDate: z10.string(),
+                Cost: z10.object({
+                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+                }),
+                Rewards: z10.array(z10.object({
+                  ItemTypeID: z10.string(),
+                  ItemID: z10.string(),
+                  Quantity: z10.number()
+                }))
+              }),
+              DiscountPercent: z10.number(),
+              DiscountedCost: z10.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+              })
+            })),
+            TotalBaseCost: z10.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+            }),
+            TotalDiscountedCost: z10.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+            }),
+            TotalDiscountPercent: z10.number(),
+            DurationRemainingInSeconds: z10.number(),
+            WholesaleOnly: z10.boolean(),
+            IsGiftable: z10.number()
+          })
+        })
+      })),
+      BundleRemainingDurationInSeconds: z10.number()
+    }),
+    SkinsPanelLayout: z10.object({
+      SingleItemOffers: z10.array(z10.string()),
+      SingleItemStoreOffers: z10.array(z10.object({
+        OfferID: z10.string(),
+        IsDirectPurchase: z10.boolean(),
+        StartDate: z10.string(),
+        Cost: z10.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+        }),
+        Rewards: z10.array(z10.object({
+          ItemTypeID: z10.string(),
+          ItemID: z10.string(),
+          Quantity: z10.number()
+        }))
+      })),
+      SingleItemOffersRemainingDurationInSeconds: z10.number()
+    }),
+    UpgradeCurrencyStore: z10.object({
+      UpgradeCurrencyOffers: z10.array(z10.object({
+        OfferID: z10.string(),
+        StorefrontItemID: z10.string(),
+        Offer: z10.object({
+          OfferID: z10.string(),
+          IsDirectPurchase: z10.boolean(),
+          StartDate: z10.string(),
+          Cost: z10.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+          }),
+          Rewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Quantity: z10.number()
+          }))
+        }),
+        DiscountedPercent: z10.number()
+      }))
+    }),
+    AccessoryStore: z10.object({
+      AccessoryStoreOffers: z10.array(z10.object({
+        Offer: z10.object({
+          OfferID: z10.string(),
+          IsDirectPurchase: z10.boolean(),
+          StartDate: z10.string(),
+          Cost: z10.object({
+            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": z10.number()
+          }),
+          Rewards: z10.array(z10.object({
+            ItemTypeID: z10.string(),
+            ItemID: z10.string(),
+            Quantity: z10.number()
+          }))
+        }),
+        ContractID: z10.string()
+      })),
+      AccessoryStoreRemainingDurationInSeconds: z10.number(),
+      StorefrontID: z10.string()
+    }),
+    PluginStores: z10.array(z10.object({
+      PluginID: z10.string(),
+      PluginOffers: z10.object({
+        StoreOffers: z10.array(z10.object({
+          PurchaseInformation: z10.object({
+            DataAssetID: z10.string(),
+            OfferID: z10.string(),
+            OfferType: z10.number(),
+            StartDate: z10.string(),
+            PrimaryCurrencyID: z10.string(),
+            Cost: z10.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+            }),
+            DiscountedCost: z10.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+            }),
+            DiscountedPercentage: z10.number(),
+            WholesaleOnly: z10.boolean(),
+            IsGiftable: z10.number()
+          }),
+          SubOffers: z10.array(z10.object({
+            PurchaseInformation: z10.object({
+              DataAssetID: z10.string(),
+              OfferID: z10.string(),
+              OfferType: z10.number(),
+              StartDate: z10.string(),
+              PrimaryCurrencyID: z10.string(),
+              Cost: z10.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+              }),
+              DiscountedCost: z10.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": z10.number()
+              }),
+              DiscountedPercentage: z10.number(),
+              Rewards: z10.array(z10.object({
+                ItemTypeID: z10.string(),
+                ItemID: z10.string(),
+                Quantity: z10.number()
+              })),
+              WholesaleOnly: z10.boolean(),
+              IsGiftable: z10.number()
+            })
+          }))
+        })),
+        RemainingDurationInSeconds: z10.number()
+      }),
+      StartDate: z10.string()
+    }))
+  }) }
 };
+
+// src/endpoints/riot/voice.ts
+import { z as z11 } from "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": z2.unknown() }
+  responses: { "200": z11.object({
+    fastEnergyMeter: z11.number(),
+    isLoopbackEnabled: z11.boolean(),
+    isMicActive: z11.boolean(),
+    isSpeakerActive: z11.boolean(),
+    micEnergy: z11.number(),
+    micVolume: z11.number(),
+    noiseFloorMeter: z11.number(),
+    speakerEnergy: z11.number(),
+    speakerVolume: z11.number(),
+    speechThresholdMeter: z11.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": z2.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": z2.unknown() }
+  responses: { "200": z11.array(z11.object({
+    handle: z11.string(),
+    is_current_device: z11.boolean(),
+    is_default: z11.boolean(),
+    is_effective_device: z11.boolean(),
+    name: z11.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": z2.unknown() }
+  responses: { "200": z11.array(z11.object({
+    handle: z11.string(),
+    is_current_device: z11.boolean(),
+    is_default: z11.boolean(),
+    is_effective_device: z11.boolean(),
+    name: z11.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": z2.unknown() }
+
+// src/api/groups/pvp.ts
+var pvp = {
+  content: e.fetchContentEndpoint,
+  accountXp: e.accountXPEndpoint,
+  playerLoadout: e.playerLoadoutEndpoint,
+  setPlayerLoadout: e.setPlayerLoadoutEndpoint,
+  playerMmr: e.playerMMREndpoint,
+  matchHistory: e.matchHistoryEndpoint,
+  matchDetails: e.matchDetailsEndpoint,
+  competitiveUpdates: e.competitiveUpdatesEndpoint,
+  leaderboard: e.leaderboardEndpoint,
+  penalties: e.penaltiesEndpoint,
+  config: e.configEndpoint,
+  nameService: e.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": z2.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": z2.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": z2.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": z2.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": z2.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": z2.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": z2.unknown() }
+
+// src/api/groups/party.ts
+import { endpoints as e2 } from "valorant-api-types";
+var party = {
+  get: e2.partyEndpoint,
+  player: e2.partyPlayerEndpoint,
+  removePlayer: e2.partyRemovePlayerEndpoint,
+  setMemberReady: e2.partySetMemberReadyEndpoint,
+  refreshCompetitiveTier: e2.refreshCompetitiveTierEndpoint,
+  refreshPlayerIdentity: e2.refreshPlayerIdentityEndpoint,
+  refreshPings: e2.refreshPingsEndpoint,
+  changeQueue: e2.changeQueueEndpoint,
+  startCustomGame: e2.startCustomGameEndpoint,
+  enterMatchmakingQueue: e2.enterMatchmakingQueueEndpoint,
+  leaveMatchmakingQueue: e2.leaveMatchmakingQueueEndpoint,
+  setAccessibility: e2.setPartyAccessibilityEndpoint,
+  setCustomGameSettings: e2.setCustomGameSettingsEndpoint,
+  invite: e2.partyInviteEndpoint,
+  requestToJoin: e2.partyRequestEndpoint,
+  declineRequest: e2.partyDeclineEndpoint,
+  customGameConfigs: e2.customGameConfigsEndpoint,
+  chatToken: e2.partyChatTokenEndpoint,
+  voiceToken: e2.partyVoiceTokenEndpoint,
+  disableCode: e2.partyDisableCodeEndpoint,
+  generateCode: e2.partyGenerateCodeEndpoint,
+  joinByCode: e2.partyJoinByCodeEndpoint
+};
+
+// src/api/groups/store.ts
+import { endpoints as e3 } from "valorant-api-types";
+var store = {
+  prices: e3.pricesEndpoint,
+  storefront: e3.storefrontEndpoint,
+  wallet: e3.walletEndpoint,
+  ownedItems: e3.ownedItemsEndpoint,
+  storefrontV3: storefrontV3Endpoint,
+  agentStore: agentStoreEndpoint,
+  allEntitlements: allEntitlementsEndpoint
+};
+
+// src/api/groups/pregame.ts
+import { endpoints as e4 } from "valorant-api-types";
+var pregame = {
+  player: e4.pregamePlayerEndpoint,
+  match: e4.pregameMatchEndpoint,
+  loadouts: e4.pregameLoadoutsEndpoint,
+  selectCharacter: e4.selectCharacterEndpoint,
+  lockCharacter: e4.lockCharacterEndpoint,
+  quit: e4.pregameQuitEndpoint
+};
+
+// src/api/groups/currentGame.ts
+import { endpoints as e5 } from "valorant-api-types";
+var currentGame = {
+  player: e5.currentGamePlayerEndpoint,
+  match: e5.currentGameMatchEndpoint,
+  loadouts: e5.currentGameLoadoutsEndpoint,
+  quit: e5.currentGameQuitEndpoint
+};
+
+// src/api/groups/contracts.ts
+import { endpoints as e6 } from "valorant-api-types";
+var contracts = {
+  itemUpgrades: e6.itemUpgradesEndpoint,
+  list: e6.contractsEndpoint,
+  activate: e6.activateContractEndpoint,
+  activeRecruitmentEvent: activeRecruitmentEventEndpoint
+};
+
+// src/api/groups/local.ts
+import { endpoints as e7 } from "valorant-api-types";
+var local = {
+  help: e7.localHelpEndpoint,
+  sessions: e7.sessionsEndpoint,
+  rsoUserInfo: e7.rsoUserInfoEndpoint,
+  clientRegion: e7.clientRegionEndpoint,
+  accountAlias: e7.accountAliasEndpoint,
+  entitlementsToken: e7.entitlementsTokenEndpoint,
+  chatSession: e7.chatSessionEndpoint,
+  friends: e7.friendsEndpoint,
+  sendFriendRequest: e7.sendFriendRequestEndpoint,
+  removeFriendRequest: e7.removeFriendRequestEndpoint,
+  presence: e7.presenceEndpoint,
+  friendRequests: e7.friendRequestsEndpoint,
+  swaggerDocs: e7.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
+import { endpoints as e8 } from "valorant-api-types";
+var chat = {
+  partyInfo: e8.partyChatInfoEndpoint,
+  pregameInfo: e8.pregameChatInfoEndpoint,
+  currentGameInfo: e8.currentGameChatInfoEndpoint,
+  allInfo: e8.allChatInfoEndpoint,
+  participants: e8.chatParticipantsEndpoint,
+  send: e8.sendChatEndpoint,
+  history: e8.chatHistoryEndpoint,
+  settings: chatSettingsEndpoint,
+  tournamentInfo: chatTournamentInfoEndpoint
+};
+
+// src/api/groups/voice.ts
+var voice = {
+  audioProperties: voiceAudioPropertiesEndpoint,
+  captureDevices: voiceCaptureDevicesEndpoint,
+  renderDevices: voiceRenderDevicesEndpoint
+};
+
+// src/api/groups/premier.ts
+var premier = {
+  seasons: premierSeasonsEndpoint,
+  activeSeason: premierActiveSeasonEndpoint,
+  conferences: premierConferencesEndpoint,
+  matchLimit: premierMatchLimitEndpoint,
+  eligibility: premierEligibilityEndpoint,
+  playerV2: premierPlayerV2Endpoint,
+  playerV3: premierPlayerV3Endpoint
+};
+
+// src/api/groups/esports.ts
+var esports = {
+  liveEventTimes: esportsLiveEventTimesEndpoint,
+  upcomingMatches: esportsUpcomingMatchesEndpoint,
+  pickemLeagues: esportsPickemLeaguesEndpoint
+};
+
+// src/api/groups/restrictions.ts
+var restrictions = {
+  avoidList: avoidListEndpoint,
+  activeFutureInterventions: activeFutureInterventionsEndpoint
 };
 
-// src/extra/store.ts
-import { z as z3 } from "zod";
-var offerSchema = z3.object({
-  OfferID: z3.string(),
-  IsDirectPurchase: z3.boolean(),
-  StartDate: z3.string(),
-  Cost: z3.record(z3.string(), z3.number()),
-  Rewards: z3.array(z3.object({
-    ItemTypeID: z3.string(),
-    ItemID: z3.string(),
-    Quantity: z3.number()
-  }).passthrough())
+// 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
+import { endpoints as e9 } from "valorant-api-types";
+var auth = {
+  cookies: e9.authCookiesEndpoint,
+  request: e9.authRequestEndpoint,
+  multiFactor: e9.multiFactorAuthenticationEndpoint,
+  cookieReauth: e9.cookieReauthEndpoint,
+  entitlement: e9.entitlementEndpoint,
+  playerInfo: e9.playerInfoEndpoint,
+  riotGeo: e9.riotGeoEndpoint,
+  pasToken: e9.pasTokenEndpoint,
+  riotClientConfig: e9.riotClientConfigEndpoint
+};
+
+// src/endpoints/catalog/index.ts
+import { z as z14 } from "zod";
+
+// src/endpoints/catalog/factory.ts
+import { z as z12 } from "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", z12.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, z12.array(schema), queryParams),
+    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
+  };
+}
+
+// src/endpoints/catalog/schemas.ts
+import { z as z13 } from "zod";
+var text = z13.string().nullish();
+var asset = z13.object({
+  uuid: z13.string(),
+  displayName: text,
+  displayIcon: text,
+  assetPath: text
+}).passthrough();
+var agentSchema = asset.extend({
+  description: text,
+  developerName: text,
+  characterTags: z13.array(z13.string()).nullish(),
+  displayIconSmall: text,
+  bustPortrait: text,
+  fullPortrait: text,
+  killfeedPortrait: text,
+  background: text,
+  isPlayableCharacter: z13.boolean(),
+  role: z13.object({ uuid: z13.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: z13.array(z13.object({ slot: z13.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+});
+var mapSchema = asset.extend({
+  coordinates: text,
+  listViewIcon: text,
+  splash: text,
+  mapUrl: text,
+  xMultiplier: z13.number(),
+  yMultiplier: z13.number(),
+  xScalarToAdd: z13.number(),
+  yScalarToAdd: z13.number(),
+  callouts: z13.array(z13.object({ regionName: z13.string(), superRegionName: z13.string(), location: z13.object({ x: z13.number(), y: z13.number() }) }).passthrough()).nullish()
+});
+var weaponSchema = asset.extend({
+  category: z13.string(),
+  defaultSkinUuid: z13.string(),
+  killStreamIcon: text,
+  weaponStats: z13.object({}).passthrough().nullish(),
+  shopData: z13.object({}).passthrough().nullish(),
+  skins: z13.array(z13.object({}).passthrough())
+});
+var skinSchema = asset.extend({
+  themeUuid: z13.string(),
+  contentTierUuid: text,
+  wallpaper: text,
+  chromas: z13.array(asset.passthrough()),
+  levels: z13.array(asset.passthrough())
+});
+var seasonSchema = z13.object({
+  uuid: z13.string(),
+  displayName: text,
+  type: text,
+  startTime: z13.string(),
+  endTime: z13.string(),
+  parentUuid: text,
+  assetPath: text
 }).passthrough();
-var bundleSchema = z3.object({
-  ID: z3.string(),
-  DataAssetID: z3.string(),
-  CurrencyID: z3.string(),
-  Items: z3.array(z3.unknown()),
-  ItemOffers: z3.array(z3.unknown()).nullish(),
-  TotalBaseCost: z3.record(z3.string(), z3.number()).nullish(),
-  TotalDiscountedCost: z3.record(z3.string(), z3.number()).nullish(),
-  TotalDiscountPercent: z3.number(),
-  DurationRemainingInSeconds: z3.number(),
-  WholesaleOnly: z3.boolean()
+var versionSchema = z13.object({
+  manifestId: z13.string(),
+  branch: z13.string(),
+  version: z13.string(),
+  buildVersion: z13.string(),
+  engineVersion: z13.string(),
+  riotClientVersion: z13.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: z13.string(),
+  buildDate: z13.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": z3.object({
-      FeaturedBundle: z3.object({
-        Bundle: bundleSchema,
-        Bundles: z3.array(bundleSchema),
-        BundleRemainingDurationInSeconds: z3.number()
-      }).passthrough(),
-      SkinsPanelLayout: z3.object({
-        SingleItemOffers: z3.array(z3.string()),
-        SingleItemStoreOffers: z3.array(offerSchema),
-        SingleItemOffersRemainingDurationInSeconds: z3.number()
-      }).passthrough(),
-      UpgradeCurrencyStore: z3.object({
-        UpgradeCurrencyOffers: z3.array(z3.object({ OfferID: z3.string(), StorefrontItemID: z3.string() }).passthrough())
-      }).passthrough(),
-      AccessoryStore: z3.object({
-        AccessoryStoreOffers: z3.array(z3.object({ Offer: offerSchema, ContractID: z3.string() }).passthrough()),
-        AccessoryStoreRemainingDurationInSeconds: z3.number(),
-        StorefrontID: z3.string()
-      }).passthrough(),
-      BonusStore: z3.object({
-        BonusStoreOffers: z3.array(z3.unknown()),
-        BonusStoreRemainingDurationInSeconds: z3.number()
-      }).passthrough().optional().describe("Only present while the night market is active"),
-      PluginStores: z3.array(z3.object({ PluginID: z3.string(), PluginOffers: z3.unknown(), StartDate: z3.string() }).passthrough()).optional()
-    }).passthrough()
-  }
+
+// src/endpoints/catalog/index.ts
+var playable = [["isPlayableCharacter", z14.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", z14.object({ uuid: z14.string(), tiers: z14.array(z14.object({ tier: z14.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", z14.object({ uuid: z14.string(), displayName: text }).passthrough());
+var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", z14.object({ uuid: z14.string(), displayName: text, titleText: text }).passthrough());
+var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", z14.object({ uuid: z14.string(), seasonUuid: z14.string(), startTime: z14.string(), endTime: z14.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: e.fetchContentEndpoint,
-    accountXp: e.accountXPEndpoint,
-    playerLoadout: e.playerLoadoutEndpoint,
-    setPlayerLoadout: e.setPlayerLoadoutEndpoint,
-    playerMmr: e.playerMMREndpoint,
-    matchHistory: e.matchHistoryEndpoint,
-    matchDetails: e.matchDetailsEndpoint,
-    competitiveUpdates: e.competitiveUpdatesEndpoint,
-    leaderboard: e.leaderboardEndpoint,
-    penalties: e.penaltiesEndpoint,
-    config: e.configEndpoint,
-    nameService: e.nameServiceEndpoint
-  },
-  party: {
-    get: e.partyEndpoint,
-    player: e.partyPlayerEndpoint,
-    removePlayer: e.partyRemovePlayerEndpoint,
-    setMemberReady: e.partySetMemberReadyEndpoint,
-    refreshCompetitiveTier: e.refreshCompetitiveTierEndpoint,
-    refreshPlayerIdentity: e.refreshPlayerIdentityEndpoint,
-    refreshPings: e.refreshPingsEndpoint,
-    changeQueue: e.changeQueueEndpoint,
-    startCustomGame: e.startCustomGameEndpoint,
-    enterMatchmakingQueue: e.enterMatchmakingQueueEndpoint,
-    leaveMatchmakingQueue: e.leaveMatchmakingQueueEndpoint,
-    setAccessibility: e.setPartyAccessibilityEndpoint,
-    setCustomGameSettings: e.setCustomGameSettingsEndpoint,
-    invite: e.partyInviteEndpoint,
-    requestToJoin: e.partyRequestEndpoint,
-    declineRequest: e.partyDeclineEndpoint,
-    customGameConfigs: e.customGameConfigsEndpoint,
-    chatToken: e.partyChatTokenEndpoint,
-    voiceToken: e.partyVoiceTokenEndpoint,
-    disableCode: e.partyDisableCodeEndpoint,
-    generateCode: e.partyGenerateCodeEndpoint,
-    joinByCode: e.partyJoinByCodeEndpoint
-  },
-  store: {
-    prices: e.pricesEndpoint,
-    storefront: e.storefrontEndpoint,
-    wallet: e.walletEndpoint,
-    ownedItems: e.ownedItemsEndpoint,
-    storefrontV3: storefrontV3Endpoint,
-    order: storeOrderEndpoint
-  },
-  pregame: {
-    player: e.pregamePlayerEndpoint,
-    match: e.pregameMatchEndpoint,
-    loadouts: e.pregameLoadoutsEndpoint,
-    selectCharacter: e.selectCharacterEndpoint,
-    lockCharacter: e.lockCharacterEndpoint,
-    quit: e.pregameQuitEndpoint,
-    chatToken: pregameChatTokenEndpoint,
-    voiceToken: pregameVoiceTokenEndpoint
-  },
-  currentGame: {
-    player: e.currentGamePlayerEndpoint,
-    match: e.currentGameMatchEndpoint,
-    loadouts: e.currentGameLoadoutsEndpoint,
-    quit: e.currentGameQuitEndpoint,
-    allChatToken: currentGameAllChatTokenEndpoint,
-    teamChatToken: currentGameTeamChatTokenEndpoint
-  },
-  contracts: {
-    itemUpgrades: e.itemUpgradesEndpoint,
-    list: e.contractsEndpoint,
-    activate: e.activateContractEndpoint,
-    activeStory: contractsActiveStoryEndpoint
-  },
-  local: {
-    help: e.localHelpEndpoint,
-    sessions: e.sessionsEndpoint,
-    rsoUserInfo: e.rsoUserInfoEndpoint,
-    clientRegion: e.clientRegionEndpoint,
-    accountAlias: e.accountAliasEndpoint,
-    entitlementsToken: e.entitlementsTokenEndpoint,
-    chatSession: e.chatSessionEndpoint,
-    friends: e.friendsEndpoint,
-    sendFriendRequest: e.sendFriendRequestEndpoint,
-    removeFriendRequest: e.removeFriendRequestEndpoint,
-    presence: e.presenceEndpoint,
-    friendRequests: e.friendRequestsEndpoint,
-    swaggerDocs: e.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: e.partyChatInfoEndpoint,
-    pregameInfo: e.pregameChatInfoEndpoint,
-    currentGameInfo: e.currentGameChatInfoEndpoint,
-    allInfo: e.allChatInfoEndpoint,
-    participants: e.chatParticipantsEndpoint,
-    send: e.sendChatEndpoint,
-    history: e.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: e.authCookiesEndpoint,
-    request: e.authRequestEndpoint,
-    multiFactor: e.multiFactorAuthenticationEndpoint,
-    cookieReauth: e.cookieReauthEndpoint,
-    entitlement: e.entitlementEndpoint,
-    playerInfo: e.playerInfoEndpoint,
-    riotGeo: e.riotGeoEndpoint,
-    pasToken: e.pasTokenEndpoint,
-    riotClientConfig: e.riotClientConfigEndpoint
-  },
-  catalog: catalogEndpoints
+  pvp,
+  party,
+  store,
+  pregame,
+  currentGame,
+  contracts,
+  local,
+  chat,
+  voice,
+  premier,
+  esports,
+  restrictions,
+  account,
+  auth,
+  catalog
 };
 
 // src/auth.ts
-import { endpoints as e2 } from "valorant-api-types";
+import { endpoints as e10 } from "valorant-api-types";
 
 // src/errors.ts
 var ValorantError = class extends Error {
@@ -894,7 +2009,7 @@ function createAuthFlows(client) {
       return toLoginResult(data);
     },
     async reauthenticate(options) {
-      const response = await client.send(e2.cookieReauthEndpoint);
+      const response = await client.send(e10.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);
@@ -1085,6 +2200,83 @@ var localTransport = async (request) => {
   });
 };
 
+// src/internal/body.ts
+import { ZodError } from "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 ZodError) return { success: false, error: thrown };
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return { success: false, error: new 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(":");
@@ -1250,8 +2442,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;
@@ -1280,13 +2470,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 {
@@ -1295,13 +2485,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;
@@ -1333,17 +2523,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)];
@@ -1357,15 +2536,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;
@@ -1373,46 +2543,6 @@ var ValorantClient = class {
     return this.#refreshing;
   }
 };
-function safeParse(schema, data) {
-  try {
-    return schema.safeParse(data);
-  } catch (thrown) {
-    if (thrown instanceof ZodError) return { success: false, error: thrown };
-    const message = thrown instanceof Error ? thrown.message : String(thrown);
-    return { success: false, error: new 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
 export * from "valorant-api-types";