@voxary/valorant-client 0.0.0-stage → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2625 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MissingContextError: () => MissingContextError,
+  MissingParameterError: () => MissingParameterError,
+  ValorantApiError: () => ValorantApiError,
+  ValorantAuthError: () => ValorantAuthError,
+  ValorantClient: () => ValorantClient,
+  ValorantContext: () => ValorantContext,
+  ValorantError: () => ValorantError,
+  ValorantNetworkError: () => ValorantNetworkError,
+  ValorantRateLimitError: () => ValorantRateLimitError,
+  ValorantValidationError: () => ValorantValidationError,
+  fetchTransport: () => fetchTransport,
+  isRegion: () => isRegion,
+  localTransport: () => localTransport,
+  parseAuthRedirect: () => parseAuthRedirect,
+  parseLockfile: () => parseLockfile,
+  readLockfile: () => readLockfile,
+  registry: () => registry,
+  shardForRegion: () => shardForRegion
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/api/groups/pvp.ts
+var import_valorant_api_types = require("valorant-api-types");
+
+// src/endpoints/riot/account.ts
+var import_zod = require("zod");
+
+// src/endpoints/riot/shared.ts
+var player = { token: true, entitlement: true, clientVersion: true, clientPlatform: true };
+
+// src/endpoints/riot/account.ts
+var dailyTicketEndpoint = {
+  name: "Daily Ticket",
+  description: "Daily ticket rewards and the matches already counted.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "daily-ticket/v1/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    Version: import_zod.z.number(),
+    DailyRewards: import_zod.z.object({
+      RemainingLifetimeSeconds: import_zod.z.number(),
+      BonusMilestonesPending: import_zod.z.number(),
+      Milestones: import_zod.z.array(import_zod.z.object({
+        Progress: import_zod.z.number(),
+        BonusApplied: import_zod.z.boolean()
+      }))
+    }),
+    ProcessedMatches: import_zod.z.array(import_zod.z.object({
+      ID: import_zod.z.string(),
+      CreatedAt: import_zod.z.string(),
+      DailyExpireTime: import_zod.z.string(),
+      PreviousDailyExpireTime: import_zod.z.string(),
+      ProgressBefore: import_zod.z.number(),
+      ProgressAfter: import_zod.z.number(),
+      XP: import_zod.z.number(),
+      SoftCurrency: import_zod.z.number(),
+      WasPenalized: import_zod.z.boolean(),
+      BonusesApplied: import_zod.z.number(),
+      DailyBonusState: import_zod.z.array(import_zod.z.boolean())
+    }))
+  }) }
+};
+var dailyTicketQueueConfigEndpoint = {
+  name: "Daily Ticket Queue Config",
+  description: "Which queues count for the daily ticket.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "daily-ticket/v1/queue-config",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    default: import_zod.z.object({
+      flatProgressPerMatch: import_zod.z.number(),
+      progressPerRoundWin: import_zod.z.boolean()
+    }),
+    queueOverrides: import_zod.z.object({
+      abilitydraftarena: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      competitive: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_abilitydraftarena: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_competitive: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_dodgeball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_fortcollins: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_hurm: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_newmap: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_skirmish2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_skirmishascension1v1: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_skirmishascension2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_snowball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_spikerush: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_swiftplay: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_unrated: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      console_valaram: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      dodgeball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      fortcollins: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      ggteam: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      hurm: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      newmap: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      premier: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      skirmish2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      skirmishascension1v1: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      skirmishascension2v2: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      snowball: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      spikerush: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      swiftplay: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      unrated: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      }),
+      valaram: import_zod.z.object({
+        flatProgressPerMatch: import_zod.z.number(),
+        progressPerRoundWin: import_zod.z.boolean()
+      })
+    })
+  }) }
+};
+var favoritesEndpoint = {
+  name: "Favorites",
+  description: "Favorited store content of the player.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "favorites/v1/players/{puuid}/favorites",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    Subject: import_zod.z.string(),
+    FavoritedContent: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+      FavoriteID: import_zod.z.string(),
+      ItemID: import_zod.z.string()
+    }))
+  }) }
+};
+var goldstarsEndpoint = {
+  name: "Goldstars",
+  description: "Goldstar definitions. Field names are obfuscated by the game.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "goldstars/v1/goldstars",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.array(import_zod.z.object({
+    id: import_zod.z.string(),
+    tempT: import_zod.z.number()
+  })) }
+};
+var goldstarsPlayerEndpoint = {
+  name: "Goldstars Player",
+  description: "Goldstars of a player. Field names are obfuscated by the game.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "goldstars/v1/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    puuid: import_zod.z.string(),
+    version: import_zod.z.number(),
+    tempS: import_zod.z.object({
+      "00000000-0000-0000-0000-000000000000": import_zod.z.object({
+        tempS: import_zod.z.string(),
+        tempA: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+          id: import_zod.z.string(),
+          tempC: import_zod.z.number(),
+          tempB: import_zod.z.number()
+        }))
+      }),
+      "8102cd81-43a0-d0d7-bd59-47b8fe9bed1b": import_zod.z.object({
+        tempS: import_zod.z.string(),
+        tempA: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+          id: import_zod.z.string(),
+          tempC: import_zod.z.number(),
+          tempB: import_zod.z.number()
+        }))
+      })
+    }),
+    tempM: import_zod.z.array(import_zod.z.object({
+      id: import_zod.z.string(),
+      tempG: import_zod.z.number(),
+      tempP: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+        tempA: import_zod.z.record(import_zod.z.string(), import_zod.z.object({
+          id: import_zod.z.string(),
+          tempV: import_zod.z.number(),
+          tempB: import_zod.z.boolean()
+        }))
+      }))
+    }))
+  }) }
+};
+var bloomlineQueuesEndpoint = {
+  name: "Bloomline Queues",
+  description: "Queues handled by the `bloomline` service. The purpose of the service is not documented.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "bloomline/v0/config/valid-queues",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    ProcessedQueues: import_zod.z.array(import_zod.z.string()),
+    PerformanceScoreQueues: import_zod.z.array(import_zod.z.string())
+  }) }
+};
+var bloomlinePlayerEndpoint = {
+  name: "Bloomline Player",
+  description: "Per-player data of the `bloomline` service. The purpose of the service is not documented.",
+  category: "Account Endpoints",
+  type: "pd",
+  suffix: "bloomline/v0/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod.z.object({
+    Subject: import_zod.z.string(),
+    Bonsais: import_zod.z.array(import_zod.z.object({
+      BonsaiID: import_zod.z.string(),
+      HypeID: import_zod.z.string().optional(),
+      BackgroundID: import_zod.z.string().optional(),
+      ClipID: import_zod.z.string().optional(),
+      BorderID: import_zod.z.string().optional(),
+      Flourish: import_zod.z.object({
+        ShortLevel: import_zod.z.number().optional(),
+        PreviousShortLevel: import_zod.z.number().optional(),
+        LongLevel: import_zod.z.number().optional(),
+        FlourishID: import_zod.z.string().optional(),
+        Points: import_zod.z.number().optional(),
+        PointsVersion: import_zod.z.number().optional()
+      }),
+      TrackProgressList: import_zod.z.array(import_zod.z.object({
+        TrackID: import_zod.z.string(),
+        TrackLevel: import_zod.z.number().optional()
+      }))
+    })),
+    LongGroupVersion: import_zod.z.number()
+  }) }
+};
+
+// src/endpoints/riot/chat.ts
+var import_zod2 = require("zod");
+var chatSettingsEndpoint = {
+  name: "Settings",
+  description: "Get chat settings",
+  category: "Local Endpoints - Chat",
+  type: "local",
+  suffix: "chat/v1/settings",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.object({
+    bounceDockIconEnabled: import_zod2.z.boolean(),
+    "chat-status-message": import_zod2.z.string(),
+    chatFilterDisabled: import_zod2.z.boolean(),
+    chatGBG: import_zod2.z.boolean(),
+    chatGroupDiscord: import_zod2.z.boolean(),
+    chatGroupMobile: import_zod2.z.boolean(),
+    chatGroupOffline: import_zod2.z.boolean(),
+    chatWindow: import_zod2.z.object({
+      detached: import_zod2.z.boolean(),
+      height: import_zod2.z.number(),
+      left: import_zod2.z.number(),
+      top: import_zod2.z.number(),
+      width: import_zod2.z.number()
+    }),
+    chatWindowDockedHeight: import_zod2.z.number(),
+    "closed-conversations": import_zod2.z.object({
+      "ff822fdf-71a3-54ac-814e-7ac752ba428d@eu1.pvp.net": import_zod2.z.number()
+    }),
+    friendRequestToastsDisabled: import_zod2.z.boolean(),
+    "hidden-conversations": import_zod2.z.object({}),
+    linkClickWarningEnabled: import_zod2.z.boolean(),
+    messageNotificationsEnabled: import_zod2.z.boolean(),
+    moreUnreadsEnabled: import_zod2.z.boolean(),
+    "muted-conversations": import_zod2.z.object({}),
+    recentlyPlayedFirstOpen: import_zod2.z.boolean(),
+    recentlyPlayedOpen: import_zod2.z.boolean(),
+    "roster-group-collapsed": import_zod2.z.object({}),
+    showWhenTypingEnabled: import_zod2.z.boolean(),
+    sortBy: import_zod2.z.string(),
+    usePlayerPreferences: import_zod2.z.boolean()
+  }) }
+};
+var chatTournamentInfoEndpoint = {
+  name: "Tournament Info",
+  description: "Get in-tournament conversations",
+  category: "Local Endpoints - Chat",
+  type: "local",
+  suffix: "chat/v6/conversations/ares-tournaments",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod2.z.object({}) }
+};
+
+// src/endpoints/riot/contracts.ts
+var import_zod3 = require("zod");
+var activeRecruitmentEventEndpoint = {
+  name: "Active Recruitment Event",
+  description: "The current agent recruitment event.",
+  category: "Contract Endpoints",
+  type: "pd",
+  suffix: "contracts/v1/agents/activeRecruitmentEvent",
+  riotRequirements: player,
+  responses: { "200": import_zod3.z.object({
+    AgentID: import_zod3.z.string(),
+    CounterID: import_zod3.z.string(),
+    MilestoneThreshold: import_zod3.z.number(),
+    StartDate: import_zod3.z.string(),
+    EndDate: import_zod3.z.string(),
+    IsActive: import_zod3.z.boolean(),
+    includedPlatforms: import_zod3.z.object({
+      console: import_zod3.z.object({
+        developmentOnly: import_zod3.z.boolean()
+      }),
+      mobile: import_zod3.z.object({
+        developmentOnly: import_zod3.z.boolean()
+      }),
+      pc: import_zod3.z.object({
+        developmentOnly: import_zod3.z.boolean()
+      })
+    })
+  }) }
+};
+
+// src/endpoints/riot/esports.ts
+var import_zod4 = require("zod");
+var esportsLiveEventTimesEndpoint = {
+  name: "Esports Live Event Times",
+  description: "Live and upcoming esports matches, pick blocks and tournaments.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v2/liveEventTimes",
+  riotRequirements: player,
+  responses: { "200": import_zod4.z.object({
+    Tournaments: import_zod4.z.array(import_zod4.z.object({
+      ID: import_zod4.z.string(),
+      StartTimeUTC: import_zod4.z.string(),
+      EndTimeUTC: import_zod4.z.string()
+    }))
+  }) }
+};
+var esportsUpcomingMatchesEndpoint = {
+  name: "Esports Upcoming Matches",
+  description: "Upcoming esports matches.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v2/upcomingMatches",
+  riotRequirements: player,
+  responses: { "200": import_zod4.z.object({}) }
+};
+var esportsPickemLeaguesEndpoint = {
+  name: "Esports Pickem Leagues",
+  description: "Pick'em leagues.",
+  category: "Esports Endpoints",
+  type: "pd",
+  suffix: "esports-service/v1/pickem/leagues",
+  riotRequirements: player,
+  responses: { "200": import_zod4.z.object({
+    PickemLeagues: import_zod4.z.array(import_zod4.z.object({
+      LeagueID: import_zod4.z.string(),
+      EldsLeagueID: import_zod4.z.string(),
+      Tournament: import_zod4.z.object({
+        ID: import_zod4.z.string(),
+        EldsTournamentID: import_zod4.z.string(),
+        LeagueID: import_zod4.z.string(),
+        PickBlocks: import_zod4.z.array(import_zod4.z.object({
+          ID: import_zod4.z.string(),
+          EldsTournamentID: import_zod4.z.string(),
+          Slug: import_zod4.z.object({
+            Slug: import_zod4.z.string()
+          }),
+          PickOpenTime: import_zod4.z.string(),
+          PickCloseTime: import_zod4.z.string(),
+          State: import_zod4.z.string(),
+          OpenLevel: import_zod4.z.string(),
+          BlockType: import_zod4.z.string(),
+          PickBlockElements: import_zod4.z.array(import_zod4.z.object({
+            ID: import_zod4.z.string(),
+            PickBlockID: import_zod4.z.string(),
+            Section: import_zod4.z.object({
+              ID: import_zod4.z.string(),
+              EldsSectionID: import_zod4.z.string(),
+              CorrectPick: import_zod4.z.object({
+                Entries: import_zod4.z.array(import_zod4.z.object({
+                  Index: import_zod4.z.number(),
+                  Correctness: import_zod4.z.string(),
+                  ParticipantID: import_zod4.z.string(),
+                  Points: import_zod4.z.number(),
+                  Rank: import_zod4.z.number()
+                })).nullable()
+              })
+            }),
+            Match: import_zod4.z.object({
+              ID: import_zod4.z.string(),
+              EldsMatchID: import_zod4.z.string(),
+              BaselinePoints: import_zod4.z.number(),
+              CorrectPick: import_zod4.z.string(),
+              ResultState: import_zod4.z.string()
+            }),
+            PickOpenTime: import_zod4.z.string(),
+            PickCloseTime: import_zod4.z.string(),
+            State: import_zod4.z.string(),
+            DisplayOrder: import_zod4.z.number()
+          })),
+          CompletionStatus: import_zod4.z.string()
+        })),
+        Participants: import_zod4.z.array(import_zod4.z.object({
+          ID: import_zod4.z.string(),
+          EldsTeamID: import_zod4.z.string()
+        }))
+      }),
+      Published: import_zod4.z.boolean()
+    }))
+  }) }
+};
+
+// src/endpoints/riot/local.ts
+var import_zod5 = require("zod");
+var localLocaleEndpoint = {
+  name: "Locale",
+  description: "Get the current locale",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riotclient/product-locales/products/valorant/patchlines/live",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.string() }
+};
+var localAvailableLocalesEndpoint = {
+  name: "Available Locales",
+  description: "Get available locales",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "rnet-product-registry/v4/available-product-locales/products/valorant/patchlines/live",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.array(import_zod5.z.string()) }
+};
+var localRiotStatusEndpoint = {
+  name: "Riot Status",
+  description: "Get game status information such as maintenances and incidents Response is an escaped JSON string.",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riot-status/v1/products/valorant/patchlines/live/deployments/{region}",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.string() }
+};
+var localAccessTokenEndpoint = {
+  name: "Access Token",
+  description: "Gets a Riot access token",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "rso-auth/v1/authorization/access-token",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.object({
+    clientId: import_zod5.z.string(),
+    expiry: import_zod5.z.number(),
+    scopes: import_zod5.z.array(import_zod5.z.string()),
+    token: import_zod5.z.string()
+  }) }
+};
+var localPluginStatusEndpoint = {
+  name: "Plugin Status",
+  description: "Gets plugin status",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "plugin-manager/v1/status",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.object({
+    state: import_zod5.z.string()
+  }) }
+};
+var localRmsSessionEndpoint = {
+  name: "Rms Session",
+  description: "Gets the token for Riot Messaging Service",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "riot-messaging-service/v1/session",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.object({
+    state: import_zod5.z.string(),
+    token: import_zod5.z.string(),
+    tokenType: import_zod5.z.string()
+  }) }
+};
+var localProcessInfoEndpoint = {
+  name: "Process Info",
+  description: "Gets the Valorant process ID",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "process-control/v1/process",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.object({
+    pid: import_zod5.z.number(),
+    status: import_zod5.z.string()
+  }) }
+};
+var localLogPathEndpoint = {
+  name: "Log Path",
+  description: "Gets the Valorant log path",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "product-session/v1/logs/path/VALORANT",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.string() }
+};
+var localEulaEndpoint = {
+  name: "Eula",
+  description: "Get the EULA",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/agreement/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.string() }
+};
+var localPrivacyPolicyEndpoint = {
+  name: "Privacy Policy",
+  description: "Get privacy policy",
+  category: "Local Endpoints",
+  type: "local",
+  suffix: "eula/v1/privacy-policy/content",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod5.z.string() }
+};
+
+// src/endpoints/riot/premier.ts
+var import_zod6 = require("zod");
+var premierSeasonsEndpoint = {
+  name: "Premier Seasons",
+  description: "All Premier seasons of the shard. The affinity in the path is the region of the context.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/premier-seasons",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    PremierSeasons: import_zod6.z.array(import_zod6.z.object({
+      ID: import_zod6.z.string(),
+      Name: import_zod6.z.string(),
+      PreviousPremierSeasonID: import_zod6.z.string(),
+      NextPremierSeasonID: import_zod6.z.string(),
+      IsActive: import_zod6.z.boolean(),
+      StartTime: import_zod6.z.string(),
+      EndTime: import_zod6.z.string(),
+      Events: import_zod6.z.array(import_zod6.z.object({
+        ID: import_zod6.z.string(),
+        Type: import_zod6.z.string(),
+        StartDateTime: import_zod6.z.string(),
+        EndDateTime: import_zod6.z.string(),
+        MapSelectionStrategy: import_zod6.z.string(),
+        MapPoolMapIDs: import_zod6.z.array(import_zod6.z.string()),
+        PointsRequiredToParticipate: import_zod6.z.number()
+      })),
+      ScheduledEvents: import_zod6.z.array(import_zod6.z.object({
+        EventID: import_zod6.z.string(),
+        EventType: import_zod6.z.string(),
+        Conference: import_zod6.z.string(),
+        DivisionGroup: import_zod6.z.string(),
+        EventPresetName: import_zod6.z.string(),
+        StartDateTime: import_zod6.z.string(),
+        EndDateTime: import_zod6.z.string(),
+        TournamentRoundTimes: import_zod6.z.array(import_zod6.z.object({
+          StartDateTime: import_zod6.z.string(),
+          EndDateTime: import_zod6.z.string()
+        }))
+      })),
+      Conferences: import_zod6.z.array(import_zod6.z.object({
+        id: import_zod6.z.string(),
+        key: import_zod6.z.string(),
+        isSuper: import_zod6.z.boolean(),
+        gamePods: import_zod6.z.array(import_zod6.z.string()),
+        timezone: import_zod6.z.string(),
+        superConference: import_zod6.z.string().optional(),
+        leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+        leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+      })),
+      Divisions: import_zod6.z.array(import_zod6.z.object({
+        Division: import_zod6.z.number(),
+        DivisionName: import_zod6.z.string(),
+        DivisionGroup: import_zod6.z.string(),
+        EventPresetName: import_zod6.z.string()
+      })),
+      DivisionThresholds: import_zod6.z.array(import_zod6.z.object({
+        playoffThresholdType: import_zod6.z.string(),
+        playoffThresholdValue: import_zod6.z.number(),
+        promotionThresholdType: import_zod6.z.string(),
+        promotionThresholdValue: import_zod6.z.number(),
+        shouldPromoteToSuperConference: import_zod6.z.boolean(),
+        skipReseedCriteria: import_zod6.z.string(),
+        conference: import_zod6.z.string().optional(),
+        division: import_zod6.z.number().optional(),
+        promotionConference: import_zod6.z.string().optional(),
+        skipReseedCriteriaValue: import_zod6.z.number().optional()
+      })),
+      EventPresets: import_zod6.z.object({
+        PRO: import_zod6.z.object({
+          EventPresetsByEventType: import_zod6.z.object({
+            LEAGUE: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            SCRIM: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            TOURNAMENT: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            })
+          })
+        }),
+        REGULAR: import_zod6.z.object({
+          EventPresetsByEventType: import_zod6.z.object({
+            LEAGUE: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            SCRIM: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            }),
+            TOURNAMENT: import_zod6.z.object({
+              EventPresetName: import_zod6.z.string(),
+              eventType: import_zod6.z.string(),
+              bestOfN: import_zod6.z.number(),
+              matchmakingStrategy: import_zod6.z.string(),
+              queueID: import_zod6.z.string(),
+              pointsConfig: import_zod6.z.object({
+                PointsForWin: import_zod6.z.number(),
+                PointsForLoss: import_zod6.z.number()
+              })
+            })
+          })
+        })
+      }),
+      FlawlessPointRequirement: import_zod6.z.number(),
+      ChampionshipPointRequirement: import_zod6.z.number(),
+      ChampionshipEventID: import_zod6.z.string(),
+      EnrollmentPhaseStartDateTime: import_zod6.z.string(),
+      EnrollmentPhaseEndDateTime: import_zod6.z.string(),
+      LeaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+      LeaderboardPromotionFinalizationDateTime: import_zod6.z.string(),
+      LeaderboardFinalizationDateTime: import_zod6.z.string(),
+      ContenderEligibilityExpiryDateTime: import_zod6.z.string(),
+      StageLockTime: import_zod6.z.string(),
+      ParticipationRewardsActIDs: import_zod6.z.array(import_zod6.z.string()),
+      ParticipationRewards: import_zod6.z.object({
+        EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+          ItemTypeID: import_zod6.z.string(),
+          ItemID: import_zod6.z.string(),
+          Amount: import_zod6.z.number()
+        }))
+      }),
+      TournamentWinnerRewards: import_zod6.z.object({}),
+      DivisionWinnerRewards: import_zod6.z.object({
+        ADVANCED: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        CONTENDER: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        ELITE: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        INTERMEDIATE: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        OPEN: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional(),
+        INVITE: import_zod6.z.object({
+          EntitlementRewards: import_zod6.z.array(import_zod6.z.object({
+            ItemTypeID: import_zod6.z.string(),
+            ItemID: import_zod6.z.string(),
+            Amount: import_zod6.z.number()
+          }))
+        }).optional()
+      }),
+      RosterRecentActivityNumSeasons: import_zod6.z.number()
+    }))
+  }) }
+};
+var premierActiveSeasonEndpoint = {
+  name: "Premier Active Season",
+  description: "The Premier season that is running now.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/premier-seasons/active",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    ID: import_zod6.z.string(),
+    Name: import_zod6.z.string(),
+    PreviousPremierSeasonID: import_zod6.z.string(),
+    NextPremierSeasonID: import_zod6.z.string(),
+    IsActive: import_zod6.z.boolean(),
+    StartTime: import_zod6.z.string(),
+    EndTime: import_zod6.z.string(),
+    Events: import_zod6.z.array(import_zod6.z.object({
+      ID: import_zod6.z.string(),
+      Type: import_zod6.z.string(),
+      StartDateTime: import_zod6.z.string(),
+      EndDateTime: import_zod6.z.string(),
+      MapSelectionStrategy: import_zod6.z.string(),
+      MapPoolMapIDs: import_zod6.z.array(import_zod6.z.string()),
+      PointsRequiredToParticipate: import_zod6.z.number()
+    })),
+    ScheduledEvents: import_zod6.z.array(import_zod6.z.object({
+      EventID: import_zod6.z.string(),
+      EventType: import_zod6.z.string(),
+      Conference: import_zod6.z.string(),
+      DivisionGroup: import_zod6.z.string(),
+      EventPresetName: import_zod6.z.string(),
+      StartDateTime: import_zod6.z.string(),
+      EndDateTime: import_zod6.z.string(),
+      TournamentRoundTimes: import_zod6.z.array(import_zod6.z.object({
+        StartDateTime: import_zod6.z.string(),
+        EndDateTime: import_zod6.z.string()
+      }))
+    })),
+    Conferences: import_zod6.z.array(import_zod6.z.object({
+      id: import_zod6.z.string(),
+      key: import_zod6.z.string(),
+      isSuper: import_zod6.z.boolean(),
+      gamePods: import_zod6.z.array(import_zod6.z.string()),
+      timezone: import_zod6.z.string(),
+      superConference: import_zod6.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+    })),
+    Divisions: import_zod6.z.array(import_zod6.z.object({
+      Division: import_zod6.z.number(),
+      DivisionName: import_zod6.z.string(),
+      DivisionGroup: import_zod6.z.string(),
+      EventPresetName: import_zod6.z.string()
+    })),
+    DivisionThresholds: import_zod6.z.array(import_zod6.z.object({
+      playoffThresholdType: import_zod6.z.string(),
+      playoffThresholdValue: import_zod6.z.number(),
+      promotionThresholdType: import_zod6.z.string(),
+      promotionThresholdValue: import_zod6.z.number(),
+      shouldPromoteToSuperConference: import_zod6.z.boolean(),
+      skipReseedCriteria: import_zod6.z.string(),
+      conference: import_zod6.z.string().optional(),
+      division: import_zod6.z.number().optional(),
+      promotionConference: import_zod6.z.string().optional(),
+      skipReseedCriteriaValue: import_zod6.z.number().optional()
+    })),
+    EventPresets: import_zod6.z.object({
+      PRO: import_zod6.z.object({
+        EventPresetsByEventType: import_zod6.z.object({
+          LEAGUE: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          SCRIM: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          TOURNAMENT: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          })
+        })
+      }),
+      REGULAR: import_zod6.z.object({
+        EventPresetsByEventType: import_zod6.z.object({
+          LEAGUE: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          SCRIM: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          }),
+          TOURNAMENT: import_zod6.z.object({
+            EventPresetName: import_zod6.z.string(),
+            eventType: import_zod6.z.string(),
+            bestOfN: import_zod6.z.number(),
+            matchmakingStrategy: import_zod6.z.string(),
+            queueID: import_zod6.z.string(),
+            pointsConfig: import_zod6.z.object({
+              PointsForWin: import_zod6.z.number(),
+              PointsForLoss: import_zod6.z.number()
+            })
+          })
+        })
+      })
+    }),
+    FlawlessPointRequirement: import_zod6.z.number(),
+    ChampionshipPointRequirement: import_zod6.z.number(),
+    ChampionshipEventID: import_zod6.z.string(),
+    EnrollmentPhaseStartDateTime: import_zod6.z.string(),
+    EnrollmentPhaseEndDateTime: import_zod6.z.string(),
+    LeaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+    LeaderboardPromotionFinalizationDateTime: import_zod6.z.string(),
+    LeaderboardFinalizationDateTime: import_zod6.z.string(),
+    ContenderEligibilityExpiryDateTime: import_zod6.z.string(),
+    StageLockTime: import_zod6.z.string(),
+    ParticipationRewards: import_zod6.z.object({}),
+    TournamentWinnerRewards: import_zod6.z.object({}),
+    DivisionWinnerRewards: import_zod6.z.object({}),
+    RosterRecentActivityNumSeasons: import_zod6.z.number()
+  }) }
+};
+var premierConferencesEndpoint = {
+  name: "Premier Conferences",
+  description: "Premier conferences of the region.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/affinities/{region}/conferences",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    PremierConferences: import_zod6.z.array(import_zod6.z.object({
+      id: import_zod6.z.string(),
+      key: import_zod6.z.string(),
+      isSuper: import_zod6.z.boolean(),
+      gamePods: import_zod6.z.array(import_zod6.z.string()),
+      timezone: import_zod6.z.string(),
+      superConference: import_zod6.z.string().optional(),
+      leaderboardPlayoffQualificationDateTime: import_zod6.z.string(),
+      leaderboardPromotionFinalizationDateTime: import_zod6.z.string()
+    }))
+  }) }
+};
+var premierMatchLimitEndpoint = {
+  name: "Premier Match Limit",
+  description: "How many Premier matches can still be played and when the limit resets.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/matchlimitinfo",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    leagueMatchLimit: import_zod6.z.number(),
+    tournamentLimit: import_zod6.z.number(),
+    timeUntilNextResetSeconds: import_zod6.z.number()
+  }) }
+};
+var premierEligibilityEndpoint = {
+  name: "Premier Eligibility",
+  description: "Whether the player can join a Premier roster.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v1/player/eligibility",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    subject: import_zod6.z.string(),
+    accountVerificationStatus: import_zod6.z.boolean(),
+    rankedPlacementCompletionStatus: import_zod6.z.boolean(),
+    matchLimitReached: import_zod6.z.boolean(),
+    isOnProvidedRoster: import_zod6.z.boolean()
+  }) }
+};
+var premierPlayerV2Endpoint = {
+  name: "Premier Player V2",
+  description: "Premier membership of a player: roster id and pending invites.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v2/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    puuid: import_zod6.z.string(),
+    rosterId: import_zod6.z.string(),
+    version: import_zod6.z.number(),
+    createdAt: import_zod6.z.number(),
+    updatedAt: import_zod6.z.number()
+  }) }
+};
+var premierPlayerV3Endpoint = {
+  name: "Premier Player V3",
+  description: "Like v2, with prestige and contender eligibility.",
+  category: "Premier Endpoints",
+  type: "pd",
+  suffix: "premier/v3/players/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod6.z.object({
+    puuid: import_zod6.z.string(),
+    rosterId: import_zod6.z.string(),
+    prestige: import_zod6.z.object({
+      earnedPrestige: import_zod6.z.boolean(),
+      earnedAura: import_zod6.z.boolean(),
+      showTag: import_zod6.z.boolean(),
+      showPlating: import_zod6.z.boolean(),
+      showAura: import_zod6.z.boolean()
+    }),
+    contenderEligibilityExpiry: import_zod6.z.string(),
+    socialVersion: import_zod6.z.number(),
+    premierVersion: import_zod6.z.number(),
+    updatedAt: import_zod6.z.number(),
+    seasons: import_zod6.z.object({
+      "08d281c5-4426-3aaa-3316-ebaf5f2c858a": import_zod6.z.object({
+        seasonId: import_zod6.z.string(),
+        hasEarnedPrestigeAura: import_zod6.z.boolean(),
+        hasEarnedParticipation: import_zod6.z.boolean(),
+        hasEarnedDivisionWinner: import_zod6.z.boolean()
+      }),
+      "91be4c20-439d-8e24-f577-4ca8a98e8dc8": import_zod6.z.object({
+        seasonId: import_zod6.z.string(),
+        hasEarnedPrestigeAura: import_zod6.z.boolean(),
+        hasEarnedParticipation: import_zod6.z.boolean(),
+        hasEarnedDivisionWinner: import_zod6.z.boolean()
+      })
+    })
+  }) }
+};
+
+// src/endpoints/riot/pvp.ts
+var import_zod7 = require("zod");
+var playerLoadoutV3Endpoint = {
+  name: "Player Loadout V3",
+  description: "Current loadout. The v2 route used by `pvp.playerLoadout` answers 404 on current clients.",
+  category: "PVP Endpoints",
+  type: "pd",
+  suffix: "personalization/v3/players/{puuid}/playerloadout",
+  riotRequirements: player,
+  responses: { "200": import_zod7.z.object({
+    Subject: import_zod7.z.string(),
+    Version: import_zod7.z.number(),
+    Guns: import_zod7.z.array(import_zod7.z.object({
+      ID: import_zod7.z.string(),
+      SkinID: import_zod7.z.string(),
+      SkinLevelID: import_zod7.z.string(),
+      ChromaID: import_zod7.z.string(),
+      CharmInstanceID: import_zod7.z.string().optional(),
+      CharmID: import_zod7.z.string().optional(),
+      CharmLevelID: import_zod7.z.string().optional()
+    })),
+    ActiveExpressions: import_zod7.z.array(import_zod7.z.object({
+      TypeID: import_zod7.z.string(),
+      AssetID: import_zod7.z.string()
+    })),
+    DynamicOptions: import_zod7.z.object({}),
+    Identity: import_zod7.z.object({
+      PlayerCardID: import_zod7.z.string(),
+      PlayerTitleID: import_zod7.z.string(),
+      AccountLevel: import_zod7.z.number(),
+      PreferredLevelBorderID: import_zod7.z.string(),
+      HideAccountLevel: import_zod7.z.boolean()
+    }),
+    Incognito: import_zod7.z.boolean()
+  }) }
+};
+
+// src/endpoints/riot/restrictions.ts
+var import_zod8 = require("zod");
+var avoidListEndpoint = {
+  name: "Avoid List",
+  description: "Players the account avoids in matchmaking.",
+  category: "Restriction Endpoints",
+  type: "pd",
+  suffix: "restrictions/v1/avoidList",
+  riotRequirements: player,
+  responses: { "200": import_zod8.z.object({
+    Subject: import_zod8.z.string()
+  }) }
+};
+var activeFutureInterventionsEndpoint = {
+  name: "Active Future Interventions",
+  description: "Upcoming or active restrictions of the account, by category.",
+  category: "Restriction Endpoints",
+  type: "pd",
+  suffix: "restrictions/v1/activeFutureInterventions",
+  riotRequirements: player,
+  responses: { "200": import_zod8.z.object({
+    Subject: import_zod8.z.string()
+  }) }
+};
+
+// src/endpoints/riot/store.ts
+var import_zod9 = require("zod");
+var agentStoreEndpoint = {
+  name: "Agent Store",
+  description: "Agents offered in the store.",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/storefronts/agent",
+  riotRequirements: player,
+  responses: { "200": import_zod9.z.object({
+    AgentStore: import_zod9.z.object({
+      AgentStoreOffers: import_zod9.z.array(import_zod9.z.object({
+        AgentID: import_zod9.z.string(),
+        StoreOffers: import_zod9.z.array(import_zod9.z.object({
+          OfferID: import_zod9.z.string(),
+          IsDirectPurchase: import_zod9.z.boolean(),
+          StartDate: import_zod9.z.string(),
+          Cost: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()),
+          Rewards: import_zod9.z.array(import_zod9.z.object({
+            ItemTypeID: import_zod9.z.string(),
+            ItemID: import_zod9.z.string(),
+            Quantity: import_zod9.z.number()
+          }))
+        }))
+      })),
+      CurrentFeaturedAgent: import_zod9.z.string(),
+      NextFeaturedAgent: import_zod9.z.string()
+    })
+  }) }
+};
+var allEntitlementsEndpoint = {
+  name: "All Entitlements",
+  description: "Everything the player owns, grouped by item type. This is the call without an item type, which is the shape `store.ownedItems` describes.",
+  category: "Store Endpoints",
+  type: "pd",
+  suffix: "store/v1/entitlements/{puuid}",
+  riotRequirements: player,
+  responses: { "200": import_zod9.z.object({
+    EntitlementsByTypes: import_zod9.z.array(import_zod9.z.object({
+      ItemTypeID: import_zod9.z.string(),
+      Entitlements: import_zod9.z.array(import_zod9.z.object({
+        TypeID: import_zod9.z.string(),
+        ItemID: import_zod9.z.string(),
+        InstanceID: import_zod9.z.string().optional()
+      }))
+    }))
+  }) }
+};
+
+// src/endpoints/riot/storefront.ts
+var import_zod10 = require("zod");
+var storefrontV3Endpoint = {
+  name: "Storefront V3",
+  description: "Get the current storefront of the player: featured bundles, the daily skin offers, accessories and night market plugins. Replaces the v2 storefront endpoint, which now answers 404.",
+  category: "Store Endpoints",
+  type: "pd",
+  method: "POST",
+  suffix: "store/v3/storefront/{puuid}",
+  headers: /* @__PURE__ */ new Map([["Content-Type", "application/json"]]),
+  riotRequirements: player,
+  responses: { "200": import_zod10.z.object({
+    FeaturedBundle: import_zod10.z.object({
+      Bundle: import_zod10.z.object({
+        ID: import_zod10.z.string(),
+        DataAssetID: import_zod10.z.string(),
+        CurrencyID: import_zod10.z.string(),
+        Items: import_zod10.z.array(import_zod10.z.object({
+          Item: import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }),
+          BasePrice: import_zod10.z.number(),
+          CurrencyID: import_zod10.z.string(),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedPrice: import_zod10.z.number(),
+          IsPromoItem: import_zod10.z.boolean()
+        })),
+        ItemOffers: import_zod10.z.array(import_zod10.z.object({
+          BundleItemOfferID: import_zod10.z.string(),
+          Offer: import_zod10.z.object({
+            OfferID: import_zod10.z.string(),
+            IsDirectPurchase: import_zod10.z.boolean(),
+            StartDate: import_zod10.z.string(),
+            Cost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            Rewards: import_zod10.z.array(import_zod10.z.object({
+              ItemTypeID: import_zod10.z.string(),
+              ItemID: import_zod10.z.string(),
+              Quantity: import_zod10.z.number()
+            }))
+          }),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedCost: import_zod10.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          })
+        })),
+        TotalBaseCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountedCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountPercent: import_zod10.z.number(),
+        DurationRemainingInSeconds: import_zod10.z.number(),
+        WholesaleOnly: import_zod10.z.boolean(),
+        IsGiftable: import_zod10.z.number()
+      }),
+      Bundles: import_zod10.z.array(import_zod10.z.object({
+        ID: import_zod10.z.string(),
+        DataAssetID: import_zod10.z.string(),
+        CurrencyID: import_zod10.z.string(),
+        Items: import_zod10.z.array(import_zod10.z.object({
+          Item: import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Amount: import_zod10.z.number()
+          }),
+          BasePrice: import_zod10.z.number(),
+          CurrencyID: import_zod10.z.string(),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedPrice: import_zod10.z.number(),
+          IsPromoItem: import_zod10.z.boolean()
+        })),
+        ItemOffers: import_zod10.z.array(import_zod10.z.object({
+          BundleItemOfferID: import_zod10.z.string(),
+          Offer: import_zod10.z.object({
+            OfferID: import_zod10.z.string(),
+            IsDirectPurchase: import_zod10.z.boolean(),
+            StartDate: import_zod10.z.string(),
+            Cost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            Rewards: import_zod10.z.array(import_zod10.z.object({
+              ItemTypeID: import_zod10.z.string(),
+              ItemID: import_zod10.z.string(),
+              Quantity: import_zod10.z.number()
+            }))
+          }),
+          DiscountPercent: import_zod10.z.number(),
+          DiscountedCost: import_zod10.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          })
+        })),
+        TotalBaseCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountedCost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        TotalDiscountPercent: import_zod10.z.number(),
+        DurationRemainingInSeconds: import_zod10.z.number(),
+        WholesaleOnly: import_zod10.z.boolean(),
+        IsGiftable: import_zod10.z.number()
+      })),
+      FeaturedTileEntries: import_zod10.z.array(import_zod10.z.object({
+        Type: import_zod10.z.number(),
+        Entry: import_zod10.z.object({
+          Bundle: import_zod10.z.object({
+            ID: import_zod10.z.string(),
+            DataAssetID: import_zod10.z.string(),
+            CurrencyID: import_zod10.z.string(),
+            Items: import_zod10.z.array(import_zod10.z.object({
+              Item: import_zod10.z.object({
+                ItemTypeID: import_zod10.z.string(),
+                ItemID: import_zod10.z.string(),
+                Amount: import_zod10.z.number()
+              }),
+              BasePrice: import_zod10.z.number(),
+              CurrencyID: import_zod10.z.string(),
+              DiscountPercent: import_zod10.z.number(),
+              DiscountedPrice: import_zod10.z.number(),
+              IsPromoItem: import_zod10.z.boolean()
+            })),
+            ItemOffers: import_zod10.z.array(import_zod10.z.object({
+              BundleItemOfferID: import_zod10.z.string(),
+              Offer: import_zod10.z.object({
+                OfferID: import_zod10.z.string(),
+                IsDirectPurchase: import_zod10.z.boolean(),
+                StartDate: import_zod10.z.string(),
+                Cost: import_zod10.z.object({
+                  "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+                }),
+                Rewards: import_zod10.z.array(import_zod10.z.object({
+                  ItemTypeID: import_zod10.z.string(),
+                  ItemID: import_zod10.z.string(),
+                  Quantity: import_zod10.z.number()
+                }))
+              }),
+              DiscountPercent: import_zod10.z.number(),
+              DiscountedCost: import_zod10.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              })
+            })),
+            TotalBaseCost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            TotalDiscountedCost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            TotalDiscountPercent: import_zod10.z.number(),
+            DurationRemainingInSeconds: import_zod10.z.number(),
+            WholesaleOnly: import_zod10.z.boolean(),
+            IsGiftable: import_zod10.z.number()
+          })
+        })
+      })),
+      BundleRemainingDurationInSeconds: import_zod10.z.number()
+    }),
+    SkinsPanelLayout: import_zod10.z.object({
+      SingleItemOffers: import_zod10.z.array(import_zod10.z.string()),
+      SingleItemStoreOffers: import_zod10.z.array(import_zod10.z.object({
+        OfferID: import_zod10.z.string(),
+        IsDirectPurchase: import_zod10.z.boolean(),
+        StartDate: import_zod10.z.string(),
+        Cost: import_zod10.z.object({
+          "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+        }),
+        Rewards: import_zod10.z.array(import_zod10.z.object({
+          ItemTypeID: import_zod10.z.string(),
+          ItemID: import_zod10.z.string(),
+          Quantity: import_zod10.z.number()
+        }))
+      })),
+      SingleItemOffersRemainingDurationInSeconds: import_zod10.z.number()
+    }),
+    UpgradeCurrencyStore: import_zod10.z.object({
+      UpgradeCurrencyOffers: import_zod10.z.array(import_zod10.z.object({
+        OfferID: import_zod10.z.string(),
+        StorefrontItemID: import_zod10.z.string(),
+        Offer: import_zod10.z.object({
+          OfferID: import_zod10.z.string(),
+          IsDirectPurchase: import_zod10.z.boolean(),
+          StartDate: import_zod10.z.string(),
+          Cost: import_zod10.z.object({
+            "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+          }),
+          Rewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Quantity: import_zod10.z.number()
+          }))
+        }),
+        DiscountedPercent: import_zod10.z.number()
+      }))
+    }),
+    AccessoryStore: import_zod10.z.object({
+      AccessoryStoreOffers: import_zod10.z.array(import_zod10.z.object({
+        Offer: import_zod10.z.object({
+          OfferID: import_zod10.z.string(),
+          IsDirectPurchase: import_zod10.z.boolean(),
+          StartDate: import_zod10.z.string(),
+          Cost: import_zod10.z.object({
+            "85ca954a-41f2-ce94-9b45-8ca3dd39a00d": import_zod10.z.number()
+          }),
+          Rewards: import_zod10.z.array(import_zod10.z.object({
+            ItemTypeID: import_zod10.z.string(),
+            ItemID: import_zod10.z.string(),
+            Quantity: import_zod10.z.number()
+          }))
+        }),
+        ContractID: import_zod10.z.string()
+      })),
+      AccessoryStoreRemainingDurationInSeconds: import_zod10.z.number(),
+      StorefrontID: import_zod10.z.string()
+    }),
+    PluginStores: import_zod10.z.array(import_zod10.z.object({
+      PluginID: import_zod10.z.string(),
+      PluginOffers: import_zod10.z.object({
+        StoreOffers: import_zod10.z.array(import_zod10.z.object({
+          PurchaseInformation: import_zod10.z.object({
+            DataAssetID: import_zod10.z.string(),
+            OfferID: import_zod10.z.string(),
+            OfferType: import_zod10.z.number(),
+            StartDate: import_zod10.z.string(),
+            PrimaryCurrencyID: import_zod10.z.string(),
+            Cost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            DiscountedCost: import_zod10.z.object({
+              "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+            }),
+            DiscountedPercentage: import_zod10.z.number(),
+            WholesaleOnly: import_zod10.z.boolean(),
+            IsGiftable: import_zod10.z.number()
+          }),
+          SubOffers: import_zod10.z.array(import_zod10.z.object({
+            PurchaseInformation: import_zod10.z.object({
+              DataAssetID: import_zod10.z.string(),
+              OfferID: import_zod10.z.string(),
+              OfferType: import_zod10.z.number(),
+              StartDate: import_zod10.z.string(),
+              PrimaryCurrencyID: import_zod10.z.string(),
+              Cost: import_zod10.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              }),
+              DiscountedCost: import_zod10.z.object({
+                "85ad13f7-3d1b-5128-9eb2-7cd8ee0b5741": import_zod10.z.number()
+              }),
+              DiscountedPercentage: import_zod10.z.number(),
+              Rewards: import_zod10.z.array(import_zod10.z.object({
+                ItemTypeID: import_zod10.z.string(),
+                ItemID: import_zod10.z.string(),
+                Quantity: import_zod10.z.number()
+              })),
+              WholesaleOnly: import_zod10.z.boolean(),
+              IsGiftable: import_zod10.z.number()
+            })
+          }))
+        })),
+        RemainingDurationInSeconds: import_zod10.z.number()
+      }),
+      StartDate: import_zod10.z.string()
+    }))
+  }) }
+};
+
+// src/endpoints/riot/voice.ts
+var import_zod11 = require("zod");
+var voiceAudioPropertiesEndpoint = {
+  name: "Audio Properties",
+  description: "Get audio properties such as if the microphone is in use",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v1/audio-properties",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod11.z.object({
+    fastEnergyMeter: import_zod11.z.number(),
+    isLoopbackEnabled: import_zod11.z.boolean(),
+    isMicActive: import_zod11.z.boolean(),
+    isSpeakerActive: import_zod11.z.boolean(),
+    micEnergy: import_zod11.z.number(),
+    micVolume: import_zod11.z.number(),
+    noiseFloorMeter: import_zod11.z.number(),
+    speakerEnergy: import_zod11.z.number(),
+    speakerVolume: import_zod11.z.number(),
+    speechThresholdMeter: import_zod11.z.number()
+  }) }
+};
+var voiceCaptureDevicesEndpoint = {
+  name: "Capture Devices",
+  description: "Get microphone input device info",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v2/devices/capture",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod11.z.array(import_zod11.z.object({
+    handle: import_zod11.z.string(),
+    is_current_device: import_zod11.z.boolean(),
+    is_default: import_zod11.z.boolean(),
+    is_effective_device: import_zod11.z.boolean(),
+    name: import_zod11.z.string()
+  })) }
+};
+var voiceRenderDevicesEndpoint = {
+  name: "Render Devices",
+  description: "Get audio output devices",
+  category: "Local Endpoints - Voice",
+  type: "local",
+  suffix: "voice-chat/v2/devices/render",
+  riotRequirements: { localAuth: true },
+  responses: { "200": import_zod11.z.array(import_zod11.z.object({
+    handle: import_zod11.z.string(),
+    is_current_device: import_zod11.z.boolean(),
+    is_default: import_zod11.z.boolean(),
+    is_effective_device: import_zod11.z.boolean(),
+    name: import_zod11.z.string()
+  })) }
+};
+
+// src/api/groups/pvp.ts
+var pvp = {
+  content: import_valorant_api_types.endpoints.fetchContentEndpoint,
+  accountXp: import_valorant_api_types.endpoints.accountXPEndpoint,
+  playerLoadout: import_valorant_api_types.endpoints.playerLoadoutEndpoint,
+  setPlayerLoadout: import_valorant_api_types.endpoints.setPlayerLoadoutEndpoint,
+  playerMmr: import_valorant_api_types.endpoints.playerMMREndpoint,
+  matchHistory: import_valorant_api_types.endpoints.matchHistoryEndpoint,
+  matchDetails: import_valorant_api_types.endpoints.matchDetailsEndpoint,
+  competitiveUpdates: import_valorant_api_types.endpoints.competitiveUpdatesEndpoint,
+  leaderboard: import_valorant_api_types.endpoints.leaderboardEndpoint,
+  penalties: import_valorant_api_types.endpoints.penaltiesEndpoint,
+  config: import_valorant_api_types.endpoints.configEndpoint,
+  nameService: import_valorant_api_types.endpoints.nameServiceEndpoint,
+  playerLoadoutV3: playerLoadoutV3Endpoint
+};
+
+// src/api/groups/party.ts
+var import_valorant_api_types2 = require("valorant-api-types");
+var party = {
+  get: import_valorant_api_types2.endpoints.partyEndpoint,
+  player: import_valorant_api_types2.endpoints.partyPlayerEndpoint,
+  removePlayer: import_valorant_api_types2.endpoints.partyRemovePlayerEndpoint,
+  setMemberReady: import_valorant_api_types2.endpoints.partySetMemberReadyEndpoint,
+  refreshCompetitiveTier: import_valorant_api_types2.endpoints.refreshCompetitiveTierEndpoint,
+  refreshPlayerIdentity: import_valorant_api_types2.endpoints.refreshPlayerIdentityEndpoint,
+  refreshPings: import_valorant_api_types2.endpoints.refreshPingsEndpoint,
+  changeQueue: import_valorant_api_types2.endpoints.changeQueueEndpoint,
+  startCustomGame: import_valorant_api_types2.endpoints.startCustomGameEndpoint,
+  enterMatchmakingQueue: import_valorant_api_types2.endpoints.enterMatchmakingQueueEndpoint,
+  leaveMatchmakingQueue: import_valorant_api_types2.endpoints.leaveMatchmakingQueueEndpoint,
+  setAccessibility: import_valorant_api_types2.endpoints.setPartyAccessibilityEndpoint,
+  setCustomGameSettings: import_valorant_api_types2.endpoints.setCustomGameSettingsEndpoint,
+  invite: import_valorant_api_types2.endpoints.partyInviteEndpoint,
+  requestToJoin: import_valorant_api_types2.endpoints.partyRequestEndpoint,
+  declineRequest: import_valorant_api_types2.endpoints.partyDeclineEndpoint,
+  customGameConfigs: import_valorant_api_types2.endpoints.customGameConfigsEndpoint,
+  chatToken: import_valorant_api_types2.endpoints.partyChatTokenEndpoint,
+  voiceToken: import_valorant_api_types2.endpoints.partyVoiceTokenEndpoint,
+  disableCode: import_valorant_api_types2.endpoints.partyDisableCodeEndpoint,
+  generateCode: import_valorant_api_types2.endpoints.partyGenerateCodeEndpoint,
+  joinByCode: import_valorant_api_types2.endpoints.partyJoinByCodeEndpoint
+};
+
+// src/api/groups/store.ts
+var import_valorant_api_types3 = require("valorant-api-types");
+var store = {
+  prices: import_valorant_api_types3.endpoints.pricesEndpoint,
+  storefront: import_valorant_api_types3.endpoints.storefrontEndpoint,
+  wallet: import_valorant_api_types3.endpoints.walletEndpoint,
+  ownedItems: import_valorant_api_types3.endpoints.ownedItemsEndpoint,
+  storefrontV3: storefrontV3Endpoint,
+  agentStore: agentStoreEndpoint,
+  allEntitlements: allEntitlementsEndpoint
+};
+
+// src/api/groups/pregame.ts
+var import_valorant_api_types4 = require("valorant-api-types");
+var pregame = {
+  player: import_valorant_api_types4.endpoints.pregamePlayerEndpoint,
+  match: import_valorant_api_types4.endpoints.pregameMatchEndpoint,
+  loadouts: import_valorant_api_types4.endpoints.pregameLoadoutsEndpoint,
+  selectCharacter: import_valorant_api_types4.endpoints.selectCharacterEndpoint,
+  lockCharacter: import_valorant_api_types4.endpoints.lockCharacterEndpoint,
+  quit: import_valorant_api_types4.endpoints.pregameQuitEndpoint
+};
+
+// src/api/groups/currentGame.ts
+var import_valorant_api_types5 = require("valorant-api-types");
+var currentGame = {
+  player: import_valorant_api_types5.endpoints.currentGamePlayerEndpoint,
+  match: import_valorant_api_types5.endpoints.currentGameMatchEndpoint,
+  loadouts: import_valorant_api_types5.endpoints.currentGameLoadoutsEndpoint,
+  quit: import_valorant_api_types5.endpoints.currentGameQuitEndpoint
+};
+
+// src/api/groups/contracts.ts
+var import_valorant_api_types6 = require("valorant-api-types");
+var contracts = {
+  itemUpgrades: import_valorant_api_types6.endpoints.itemUpgradesEndpoint,
+  list: import_valorant_api_types6.endpoints.contractsEndpoint,
+  activate: import_valorant_api_types6.endpoints.activateContractEndpoint,
+  activeRecruitmentEvent: activeRecruitmentEventEndpoint
+};
+
+// src/api/groups/local.ts
+var import_valorant_api_types7 = require("valorant-api-types");
+var local = {
+  help: import_valorant_api_types7.endpoints.localHelpEndpoint,
+  sessions: import_valorant_api_types7.endpoints.sessionsEndpoint,
+  rsoUserInfo: import_valorant_api_types7.endpoints.rsoUserInfoEndpoint,
+  clientRegion: import_valorant_api_types7.endpoints.clientRegionEndpoint,
+  accountAlias: import_valorant_api_types7.endpoints.accountAliasEndpoint,
+  entitlementsToken: import_valorant_api_types7.endpoints.entitlementsTokenEndpoint,
+  chatSession: import_valorant_api_types7.endpoints.chatSessionEndpoint,
+  friends: import_valorant_api_types7.endpoints.friendsEndpoint,
+  sendFriendRequest: import_valorant_api_types7.endpoints.sendFriendRequestEndpoint,
+  removeFriendRequest: import_valorant_api_types7.endpoints.removeFriendRequestEndpoint,
+  presence: import_valorant_api_types7.endpoints.presenceEndpoint,
+  friendRequests: import_valorant_api_types7.endpoints.friendRequestsEndpoint,
+  swaggerDocs: import_valorant_api_types7.endpoints.localSwaggerDocsEndpoint,
+  eula: localEulaEndpoint,
+  privacyPolicy: localPrivacyPolicyEndpoint,
+  availableLocales: localAvailableLocalesEndpoint,
+  locale: localLocaleEndpoint,
+  riotStatus: localRiotStatusEndpoint,
+  accessToken: localAccessTokenEndpoint,
+  pluginStatus: localPluginStatusEndpoint,
+  rmsSession: localRmsSessionEndpoint,
+  processInfo: localProcessInfoEndpoint,
+  logPath: localLogPathEndpoint
+};
+
+// src/api/groups/chat.ts
+var import_valorant_api_types8 = require("valorant-api-types");
+var chat = {
+  partyInfo: import_valorant_api_types8.endpoints.partyChatInfoEndpoint,
+  pregameInfo: import_valorant_api_types8.endpoints.pregameChatInfoEndpoint,
+  currentGameInfo: import_valorant_api_types8.endpoints.currentGameChatInfoEndpoint,
+  allInfo: import_valorant_api_types8.endpoints.allChatInfoEndpoint,
+  participants: import_valorant_api_types8.endpoints.chatParticipantsEndpoint,
+  send: import_valorant_api_types8.endpoints.sendChatEndpoint,
+  history: import_valorant_api_types8.endpoints.chatHistoryEndpoint,
+  settings: chatSettingsEndpoint,
+  tournamentInfo: chatTournamentInfoEndpoint
+};
+
+// src/api/groups/voice.ts
+var voice = {
+  audioProperties: voiceAudioPropertiesEndpoint,
+  captureDevices: voiceCaptureDevicesEndpoint,
+  renderDevices: voiceRenderDevicesEndpoint
+};
+
+// src/api/groups/premier.ts
+var premier = {
+  seasons: premierSeasonsEndpoint,
+  activeSeason: premierActiveSeasonEndpoint,
+  conferences: premierConferencesEndpoint,
+  matchLimit: premierMatchLimitEndpoint,
+  eligibility: premierEligibilityEndpoint,
+  playerV2: premierPlayerV2Endpoint,
+  playerV3: premierPlayerV3Endpoint
+};
+
+// src/api/groups/esports.ts
+var esports = {
+  liveEventTimes: esportsLiveEventTimesEndpoint,
+  upcomingMatches: esportsUpcomingMatchesEndpoint,
+  pickemLeagues: esportsPickemLeaguesEndpoint
+};
+
+// src/api/groups/restrictions.ts
+var restrictions = {
+  avoidList: avoidListEndpoint,
+  activeFutureInterventions: activeFutureInterventionsEndpoint
+};
+
+// src/api/groups/account.ts
+var account = {
+  dailyTicket: dailyTicketEndpoint,
+  dailyTicketQueueConfig: dailyTicketQueueConfigEndpoint,
+  favorites: favoritesEndpoint,
+  goldstars: goldstarsEndpoint,
+  goldstarsPlayer: goldstarsPlayerEndpoint,
+  bloomlineQueues: bloomlineQueuesEndpoint,
+  bloomlinePlayer: bloomlinePlayerEndpoint
+};
+
+// src/api/groups/auth.ts
+var import_valorant_api_types9 = require("valorant-api-types");
+var auth = {
+  cookies: import_valorant_api_types9.endpoints.authCookiesEndpoint,
+  request: import_valorant_api_types9.endpoints.authRequestEndpoint,
+  multiFactor: import_valorant_api_types9.endpoints.multiFactorAuthenticationEndpoint,
+  cookieReauth: import_valorant_api_types9.endpoints.cookieReauthEndpoint,
+  entitlement: import_valorant_api_types9.endpoints.entitlementEndpoint,
+  playerInfo: import_valorant_api_types9.endpoints.playerInfoEndpoint,
+  riotGeo: import_valorant_api_types9.endpoints.riotGeoEndpoint,
+  pasToken: import_valorant_api_types9.endpoints.pasTokenEndpoint,
+  riotClientConfig: import_valorant_api_types9.endpoints.riotClientConfigEndpoint
+};
+
+// src/endpoints/catalog/index.ts
+var import_zod14 = require("zod");
+
+// src/endpoints/catalog/factory.ts
+var import_zod12 = require("zod");
+
+// src/envelope.ts
+var enveloped = /* @__PURE__ */ new WeakSet();
+function markEnveloped(endpoint2) {
+  enveloped.add(endpoint2);
+  return endpoint2;
+}
+function unwrapEnvelope(endpoint2, body) {
+  if (enveloped.has(endpoint2) && typeof body === "object" && body !== null && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+
+// src/endpoints/catalog/factory.ts
+var BASE = "https://valorant-api.com/v1/";
+function query(queryParams = []) {
+  return new Map([
+    ["language", import_zod12.z.string().optional().describe("Language code such as `fr-FR`. Defaults to `en-US`.")],
+    ...queryParams
+  ]);
+}
+function endpoint(name, description, path, schema, queryParams = []) {
+  return markEnveloped({
+    name,
+    description,
+    category: "Valorant-API.com",
+    type: "other",
+    suffix: `${BASE}${path}`,
+    query: query(queryParams),
+    responses: { "200": schema }
+  });
+}
+function collection(title, singular, path, schema, queryParams = []) {
+  return {
+    list: endpoint(title, `List of ${title.toLowerCase()}`, path, import_zod12.z.array(schema), queryParams),
+    one: endpoint(singular, `One ${singular.toLowerCase()} by UUID`, `${path}/{uuid}`, schema)
+  };
+}
+
+// src/endpoints/catalog/schemas.ts
+var import_zod13 = require("zod");
+var text = import_zod13.z.string().nullish();
+var asset = import_zod13.z.object({
+  uuid: import_zod13.z.string(),
+  displayName: text,
+  displayIcon: text,
+  assetPath: text
+}).passthrough();
+var agentSchema = asset.extend({
+  description: text,
+  developerName: text,
+  characterTags: import_zod13.z.array(import_zod13.z.string()).nullish(),
+  displayIconSmall: text,
+  bustPortrait: text,
+  fullPortrait: text,
+  killfeedPortrait: text,
+  background: text,
+  isPlayableCharacter: import_zod13.z.boolean(),
+  role: import_zod13.z.object({ uuid: import_zod13.z.string(), displayName: text, description: text, displayIcon: text }).passthrough().nullish(),
+  abilities: import_zod13.z.array(import_zod13.z.object({ slot: import_zod13.z.string(), displayName: text, description: text, displayIcon: text }).passthrough()).nullish()
+});
+var mapSchema = asset.extend({
+  coordinates: text,
+  listViewIcon: text,
+  splash: text,
+  mapUrl: text,
+  xMultiplier: import_zod13.z.number(),
+  yMultiplier: import_zod13.z.number(),
+  xScalarToAdd: import_zod13.z.number(),
+  yScalarToAdd: import_zod13.z.number(),
+  callouts: import_zod13.z.array(import_zod13.z.object({ regionName: import_zod13.z.string(), superRegionName: import_zod13.z.string(), location: import_zod13.z.object({ x: import_zod13.z.number(), y: import_zod13.z.number() }) }).passthrough()).nullish()
+});
+var weaponSchema = asset.extend({
+  category: import_zod13.z.string(),
+  defaultSkinUuid: import_zod13.z.string(),
+  killStreamIcon: text,
+  weaponStats: import_zod13.z.object({}).passthrough().nullish(),
+  shopData: import_zod13.z.object({}).passthrough().nullish(),
+  skins: import_zod13.z.array(import_zod13.z.object({}).passthrough())
+});
+var skinSchema = asset.extend({
+  themeUuid: import_zod13.z.string(),
+  contentTierUuid: text,
+  wallpaper: text,
+  chromas: import_zod13.z.array(asset.passthrough()),
+  levels: import_zod13.z.array(asset.passthrough())
+});
+var seasonSchema = import_zod13.z.object({
+  uuid: import_zod13.z.string(),
+  displayName: text,
+  type: text,
+  startTime: import_zod13.z.string(),
+  endTime: import_zod13.z.string(),
+  parentUuid: text,
+  assetPath: text
+}).passthrough();
+var versionSchema = import_zod13.z.object({
+  manifestId: import_zod13.z.string(),
+  branch: import_zod13.z.string(),
+  version: import_zod13.z.string(),
+  buildVersion: import_zod13.z.string(),
+  engineVersion: import_zod13.z.string(),
+  riotClientVersion: import_zod13.z.string().describe("Value of the X-Riot-ClientVersion header"),
+  riotClientBuild: import_zod13.z.string(),
+  buildDate: import_zod13.z.string()
+}).passthrough();
+
+// src/endpoints/catalog/index.ts
+var playable = [["isPlayableCharacter", import_zod14.z.boolean().optional().describe("Only return playable agents. Skips the duplicate Sova.")]];
+var agents = collection("Agents", "Agent", "agents", agentSchema, playable);
+var buddies = collection("Buddies", "Buddy", "buddies", asset);
+var buddyLevels = collection("Buddy Levels", "Buddy Level", "buddies/levels", asset);
+var bundles = collection("Bundles", "Bundle", "bundles", asset);
+var ceremonies = collection("Ceremonies", "Ceremony", "ceremonies", asset);
+var competitiveTiers = collection("Competitive Tiers", "Competitive Tier Set", "competitivetiers", import_zod14.z.object({ uuid: import_zod14.z.string(), tiers: import_zod14.z.array(import_zod14.z.object({ tier: import_zod14.z.number(), tierName: text, division: text, color: text }).passthrough()) }).passthrough());
+var contentTiers = collection("Content Tiers", "Content Tier", "contenttiers", asset);
+var contracts2 = collection("Contracts", "Contract", "contracts", asset);
+var currencies = collection("Currencies", "Currency", "currencies", asset);
+var events = collection("Events", "Event", "events", asset);
+var flex = collection("Flex", "Flex Item", "flex", asset);
+var gamemodes = collection("Gamemodes", "Gamemode", "gamemodes", asset);
+var gamemodeEquippables = collection("Gamemode Equippables", "Gamemode Equippable", "gamemodes/equippables", asset);
+var gear = collection("Gear", "Gear Item", "gear", asset);
+var levelBorders = collection("Level Borders", "Level Border", "levelborders", asset);
+var maps = collection("Maps", "Map", "maps", mapSchema);
+var missions = collection("Missions", "Mission", "missions", import_zod14.z.object({ uuid: import_zod14.z.string(), displayName: text }).passthrough());
+var playerCards = collection("Player Cards", "Player Card", "playercards", asset);
+var playerTitles = collection("Player Titles", "Player Title", "playertitles", import_zod14.z.object({ uuid: import_zod14.z.string(), displayName: text, titleText: text }).passthrough());
+var seasons = collection("Seasons", "Season", "seasons", seasonSchema);
+var competitiveSeasons = collection("Competitive Seasons", "Competitive Season", "seasons/competitive", import_zod14.z.object({ uuid: import_zod14.z.string(), seasonUuid: import_zod14.z.string(), startTime: import_zod14.z.string(), endTime: import_zod14.z.string() }).passthrough());
+var sprays = collection("Sprays", "Spray", "sprays", asset);
+var sprayLevels = collection("Spray Levels", "Spray Level", "sprays/levels", asset);
+var themes = collection("Themes", "Theme", "themes", asset);
+var weapons = collection("Weapons", "Weapon", "weapons", weaponSchema);
+var weaponSkins = collection("Weapon Skins", "Weapon Skin", "weapons/skins", skinSchema);
+var weaponSkinChromas = collection("Weapon Skin Chromas", "Weapon Skin Chroma", "weapons/skinchromas", asset);
+var weaponSkinLevels = collection("Weapon Skin Levels", "Weapon Skin Level", "weapons/skinlevels", asset);
+var catalogEndpoints = {
+  agents: agents.list,
+  agent: agents.one,
+  buddies: buddies.list,
+  buddy: buddies.one,
+  buddyLevels: buddyLevels.list,
+  buddyLevel: buddyLevels.one,
+  bundles: bundles.list,
+  bundle: bundles.one,
+  ceremonies: ceremonies.list,
+  ceremony: ceremonies.one,
+  competitiveTiers: competitiveTiers.list,
+  competitiveTier: competitiveTiers.one,
+  contentTiers: contentTiers.list,
+  contentTier: contentTiers.one,
+  contracts: contracts2.list,
+  contract: contracts2.one,
+  currencies: currencies.list,
+  currency: currencies.one,
+  events: events.list,
+  event: events.one,
+  flex: flex.list,
+  flexItem: flex.one,
+  gamemodes: gamemodes.list,
+  gamemode: gamemodes.one,
+  gamemodeEquippables: gamemodeEquippables.list,
+  gamemodeEquippable: gamemodeEquippables.one,
+  gear: gear.list,
+  gearItem: gear.one,
+  levelBorders: levelBorders.list,
+  levelBorder: levelBorders.one,
+  maps: maps.list,
+  map: maps.one,
+  missions: missions.list,
+  mission: missions.one,
+  playerCards: playerCards.list,
+  playerCard: playerCards.one,
+  playerTitles: playerTitles.list,
+  playerTitle: playerTitles.one,
+  seasons: seasons.list,
+  season: seasons.one,
+  competitiveSeasons: competitiveSeasons.list,
+  competitiveSeason: competitiveSeasons.one,
+  sprays: sprays.list,
+  spray: sprays.one,
+  sprayLevels: sprayLevels.list,
+  sprayLevel: sprayLevels.one,
+  themes: themes.list,
+  theme: themes.one,
+  version: endpoint("Version", "Current game version and the matching client version", "version", versionSchema),
+  weapons: weapons.list,
+  weapon: weapons.one,
+  weaponSkins: weaponSkins.list,
+  weaponSkin: weaponSkins.one,
+  weaponSkinChromas: weaponSkinChromas.list,
+  weaponSkinChroma: weaponSkinChromas.one,
+  weaponSkinLevels: weaponSkinLevels.list,
+  weaponSkinLevel: weaponSkinLevels.one
+};
+
+// src/api/groups/catalog.ts
+var catalog = catalogEndpoints;
+
+// src/api/registry.ts
+var registry = {
+  pvp,
+  party,
+  store,
+  pregame,
+  currentGame,
+  contracts,
+  local,
+  chat,
+  voice,
+  premier,
+  esports,
+  restrictions,
+  account,
+  auth,
+  catalog
+};
+
+// src/auth.ts
+var import_valorant_api_types10 = require("valorant-api-types");
+
+// src/errors.ts
+var ValorantError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var MissingContextError = class extends ValorantError {
+  constructor(key) {
+    super(`Context value "${key}" is required for this request but is not set`);
+    this.key = key;
+  }
+  key;
+};
+var MissingParameterError = class extends ValorantError {
+  constructor(parameter, endpoint2) {
+    super(`Path parameter "${parameter}" is required for "${endpoint2}"`);
+    this.parameter = parameter;
+    this.endpoint = endpoint2;
+  }
+  parameter;
+  endpoint;
+};
+var ValorantNetworkError = class extends ValorantError {
+  constructor(message, url, options) {
+    super(message, options);
+    this.url = url;
+  }
+  url;
+};
+var ValorantValidationError = class extends ValorantError {
+  constructor(target, endpoint2, issues, data) {
+    super(`Invalid ${target} for "${endpoint2}": ${issues.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).slice(0, 5).join("; ")}`);
+    this.target = target;
+    this.endpoint = endpoint2;
+    this.issues = issues;
+    this.data = data;
+  }
+  target;
+  endpoint;
+  issues;
+  data;
+};
+var ValorantApiError = class extends ValorantError {
+  constructor(status, endpoint2, url, body, headers) {
+    const code = extractErrorCode(body);
+    super(`${endpoint2} failed with HTTP ${status}${code ? ` (${code})` : ""}`);
+    this.status = status;
+    this.endpoint = endpoint2;
+    this.url = url;
+    this.body = body;
+    this.headers = headers;
+    this.errorCode = code;
+  }
+  status;
+  endpoint;
+  url;
+  body;
+  headers;
+  errorCode;
+};
+var ValorantAuthError = class extends ValorantApiError {
+};
+var ValorantRateLimitError = class extends ValorantApiError {
+  constructor(status, endpoint2, url, body, headers, retryAfterMs) {
+    super(status, endpoint2, url, body, headers);
+    this.retryAfterMs = retryAfterMs;
+  }
+  retryAfterMs;
+};
+function extractErrorCode(body) {
+  if (typeof body === "object" && body !== null && "errorCode" in body) {
+    const code = body.errorCode;
+    return typeof code === "string" ? code : void 0;
+  }
+  return void 0;
+}
+
+// src/auth.ts
+function parseAuthRedirect(location) {
+  const fragment = location.split("#")[1];
+  if (fragment === void 0) return void 0;
+  const params = new URLSearchParams(fragment);
+  const accessToken = params.get("access_token");
+  const idToken = params.get("id_token");
+  if (accessToken === null || idToken === null) return void 0;
+  const expiresIn = Number(params.get("expires_in"));
+  return { accessToken, idToken, expiresIn: Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn : void 0 };
+}
+var AUTH_COOKIES_BODY = {
+  client_id: "play-valorant-web-prod",
+  nonce: "1",
+  redirect_uri: "https://playvalorant.com/opt_in",
+  response_type: "token id_token",
+  scope: "account openid"
+};
+function createAuthFlows(client) {
+  const ctx = client.context;
+  function applyTokens(tokens) {
+    if (tokens) ctx.update({ accessToken: tokens.accessToken, idToken: tokens.idToken });
+  }
+  function toLoginResult(data) {
+    const body = data ?? {};
+    if (body.type === "multifactor") return { status: "multifactor", email: body.multifactor?.email ?? "" };
+    const redirect = body.success?.redirect_url ?? JSON.stringify(data);
+    const tokens = parseAuthRedirect(redirect.replaceAll("\\u0026", "&"));
+    applyTokens(tokens);
+    return { status: "success", tokens };
+  }
+  return {
+    async login(options) {
+      await client.auth.cookies({ body: AUTH_COOKIES_BODY });
+      const data = await client.auth.request({
+        body: {
+          type: "auth",
+          language: "en_US",
+          remember: options.remember ?? true,
+          riot_identity: { captcha: options.captcha, username: options.username, password: options.password }
+        }
+      });
+      return toLoginResult(data);
+    },
+    async submitMfa(code, rememberDevice = true) {
+      const data = await client.auth.multiFactor({ body: { type: "multifactor", multifactor: { otp: code, rememberDevice } } });
+      return toLoginResult(data);
+    },
+    async reauthenticate(options) {
+      const response = await client.send(import_valorant_api_types10.endpoints.cookieReauthEndpoint);
+      const tokens = parseAuthRedirect(response.headers.get("location") ?? "");
+      if (tokens === void 0) throw new ValorantError("Cookie reauthentication failed: the session cookies are missing or expired, log in again");
+      applyTokens(tokens);
+      await this.establishSession(options);
+      return tokens;
+    },
+    async establishSession(options) {
+      const { entitlements_token } = await client.auth.entitlement();
+      ctx.set("entitlementToken", entitlements_token);
+      const info = await client.auth.playerInfo();
+      ctx.set("puuid", info.sub);
+      const geo = await client.auth.riotGeo({ body: { id_token: ctx.require("idToken") } });
+      ctx.applyAffinity(geo.affinities.live);
+      if (options?.fetchClientVersion) await this.fetchClientVersion();
+    },
+    async fetchClientVersion() {
+      const response = await client.transport({
+        method: "GET",
+        url: "https://valorant-api.com/v1/version",
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(15e3)
+      });
+      const version = JSON.parse(response.text).data?.riotClientVersion;
+      if (!version) throw new ValorantError("valorant-api.com did not return a client version");
+      ctx.set("clientVersion", version);
+      return version;
+    }
+  };
+}
+
+// src/context.ts
+var DEFAULT_PLATFORM = btoa(JSON.stringify({
+  platformType: "PC",
+  platformOS: "Windows",
+  platformOSVersion: "10.0.19042.1.256.64bit",
+  platformChipset: "Unknown"
+}));
+var SECRET_KEYS = ["accessToken", "entitlementToken", "idToken", "pasToken", "cookies", "localPassword"];
+var REGION_TO_SHARD = { na: "na", latam: "na", br: "na", eu: "eu", ap: "ap", kr: "kr" };
+function isRegion(value) {
+  return Object.hasOwn(REGION_TO_SHARD, value);
+}
+function shardForRegion(region) {
+  return REGION_TO_SHARD[region];
+}
+var ValorantContext = class {
+  #state;
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(initial = {}) {
+    this.#state = Object.freeze({ clientPlatform: DEFAULT_PLATFORM, ...stripUndefined(initial) });
+  }
+  get(key) {
+    return this.#state[key];
+  }
+  /** Like {@link get}, but throws {@link MissingContextError} when the value is not set. */
+  require(key) {
+    const value = this.#state[key];
+    if (value === void 0) throw new MissingContextError(key);
+    return value;
+  }
+  has(key) {
+    return this.#state[key] !== void 0;
+  }
+  /** Sets one value. `undefined` removes it. */
+  set(key, value) {
+    this.update({ [key]: value });
+  }
+  /** Merges a patch into the state. Keys set to `undefined` are removed. */
+  update(patch) {
+    this.#commit({ ...this.#state, ...patch });
+  }
+  /** Replaces the whole state. The default client platform is kept unless provided. */
+  replace(next) {
+    this.#commit({ clientPlatform: DEFAULT_PLATFORM, ...next });
+  }
+  /** Removes everything except the default client platform. */
+  clear() {
+    this.replace({});
+  }
+  /** Sets region and the matching shard from a Riot affinity (`eu`, `latam`, ...). Unknown values are ignored. */
+  applyAffinity(affinity) {
+    if (!isRegion(affinity)) return false;
+    this.update({ region: affinity, shard: shardForRegion(affinity) });
+    return true;
+  }
+  setCookie(name, value) {
+    const cookies = { ...this.#state.cookies };
+    if (value === void 0) delete cookies[name];
+    else cookies[name] = value;
+    this.update({ cookies });
+  }
+  cookieHeader() {
+    const entries = Object.entries(this.#state.cookies ?? {});
+    return entries.length === 0 ? void 0 : entries.map(([name, value]) => `${name}=${value}`).join("; ");
+  }
+  /** Immutable copy of the current state. Contains secrets. */
+  snapshot() {
+    return this.#state;
+  }
+  /** Calls `listener` after every change. Returns an unsubscribe function. */
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => void this.#listeners.delete(listener);
+  }
+  /** State with secrets masked, safe to log. */
+  redacted() {
+    const out = { ...this.#state };
+    for (const key of SECRET_KEYS) {
+      if (out[key] !== void 0) out[key] = "[redacted]";
+    }
+    return out;
+  }
+  toJSON() {
+    return this.redacted();
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.redacted();
+  }
+  #commit(next) {
+    const previous = this.#state;
+    const clean = Object.freeze(stripUndefined(next));
+    const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(clean)]);
+    const changed = [...keys].filter((key) => !sameValue(previous[key], clean[key]));
+    if (changed.length === 0) return;
+    this.#state = clean;
+    for (const listener of [...this.#listeners]) listener(clean, changed);
+  }
+};
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+function sameValue(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const aEntries = Object.entries(a);
+  const bEntries = Object.entries(b);
+  return aEntries.length === bEntries.length && aEntries.every(([key, value]) => Object.is(b[key], value));
+}
+
+// src/http.ts
+var fetchTransport = async (request) => {
+  const response = await fetch(request.url, {
+    method: request.method,
+    headers: request.headers,
+    body: request.body,
+    signal: request.signal,
+    redirect: "manual"
+  });
+  return {
+    status: response.status,
+    headers: response.headers,
+    setCookies: response.headers.getSetCookie(),
+    text: await response.text()
+  };
+};
+var localTransport = async (request) => {
+  const { request: httpsRequest } = await import("https");
+  const url = new URL(request.url);
+  if (url.hostname !== "127.0.0.1" && url.hostname !== "localhost") {
+    throw new Error(`localTransport only talks to loopback hosts, got ${url.hostname}`);
+  }
+  return new Promise((resolve, reject) => {
+    const req = httpsRequest(url, {
+      method: request.method,
+      headers: request.headers,
+      rejectUnauthorized: false,
+      signal: request.signal
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("error", reject);
+      res.on("end", () => {
+        const headers = new Headers();
+        for (const [name, value] of Object.entries(res.headers)) {
+          if (Array.isArray(value)) value.forEach((v) => headers.append(name, v));
+          else if (value !== void 0) headers.set(name, value);
+        }
+        resolve({
+          status: res.statusCode ?? 0,
+          headers,
+          setCookies: res.headers["set-cookie"] ?? [],
+          text: Buffer.concat(chunks).toString("utf8")
+        });
+      });
+    });
+    req.on("error", reject);
+    req.end(request.body);
+  });
+};
+
+// src/internal/body.ts
+var import_zod15 = require("zod");
+function parseBody(text2) {
+  if (text2 === "") return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function safeParse(schema, data) {
+  try {
+    return schema.safeParse(data);
+  } catch (thrown) {
+    if (thrown instanceof import_zod15.ZodError) return { success: false, error: thrown };
+    const message = thrown instanceof Error ? thrown.message : String(thrown);
+    return { success: false, error: new import_zod15.ZodError([{ code: "custom", path: [], message: `Schema transform threw: ${message}` }]) };
+  }
+}
+
+// src/internal/cookies.ts
+function storeCookies(context, setCookies) {
+  for (const line of setCookies) {
+    const [pair = "", ...attributes] = line.split(";").map((part) => part.trim());
+    const separator = pair.indexOf("=");
+    if (separator <= 0) continue;
+    const name = pair.slice(0, separator);
+    const value = pair.slice(separator + 1);
+    const expired = value === "" || attributes.some((a) => a.toLowerCase() === "max-age=0");
+    context.setCookie(name, expired ? void 0 : value);
+  }
+}
+
+// src/internal/retry.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE"]);
+function isIdempotent(method) {
+  return IDEMPOTENT.has(method);
+}
+function isRetryableStatus(status, method) {
+  return RETRYABLE_STATUS.has(status) && (status === 429 || isIdempotent(method));
+}
+function parseRetryAfter(value) {
+  if (value === null) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function backoff(attempt, retry) {
+  const base = retry?.baseDelayMs ?? 500;
+  const max = retry?.maxDelayMs ?? 8e3;
+  return Math.min(max, base * 2 ** attempt) * (0.5 + Math.random() / 2);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+  });
+}
+
+// src/internal/failure.ts
+function toApiError(endpoint2, request, response) {
+  const body = parseBody(response.text);
+  const args = [response.status, endpoint2.name, request.url, body, response.headers];
+  if (response.status === 429) return new ValorantRateLimitError(...args, parseRetryAfter(response.headers.get("retry-after")));
+  const needsToken = endpoint2.riotRequirements?.token === true;
+  const badClaims = typeof body === "object" && body !== null && body.errorCode === "BAD_CLAIMS";
+  if (needsToken && (response.status === 401 || response.status === 400 && badClaims)) return new ValorantAuthError(...args);
+  return new ValorantApiError(...args);
+}
+
+// src/local.ts
+function parseLockfile(content) {
+  const [name, pid, port, password, protocol] = content.trim().split(":");
+  if (!name || !pid || !port || !password || !protocol) throw new ValorantError("Malformed lockfile");
+  return { name, pid: Number(pid), port: Number(port), password, protocol };
+}
+async function readLockfile(path) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const file = path ?? join(process.env["LOCALAPPDATA"] ?? "", "Riot Games", "Riot Client", "Config", "lockfile");
+  try {
+    return parseLockfile(await readFile(file, "utf8"));
+  } catch (cause) {
+    throw new ValorantError(`Could not read the Riot Client lockfile at "${file}". Is the Riot Client running?`, { cause });
+  }
+}
+function createLocalFlows(client) {
+  const ctx = client.context;
+  return {
+    async connect(options) {
+      const lockfile = await readLockfile(options?.lockfilePath);
+      ctx.update({ localPort: lockfile.port, localPassword: lockfile.password });
+      const tokens = await client.local.entitlementsToken();
+      ctx.update({ accessToken: tokens.accessToken, entitlementToken: tokens.token, puuid: tokens.subject });
+      const sessions = await client.local.sessions();
+      const valorant = Object.values(sessions).find((session) => session.productId === "valorant");
+      if (valorant) {
+        ctx.set("clientVersion", valorant.version);
+        const region = launchArgument(valorant.launchConfiguration.arguments, "ares-deployment");
+        if (region !== void 0 && isRegion(region)) ctx.update({ region, shard: shardForRegion(region) });
+      }
+      if (!ctx.has("region")) {
+        const info = await client.auth.playerInfo();
+        const affinity = Object.values(info.affinity ?? {}).find(isRegion);
+        if (affinity !== void 0) ctx.applyAffinity(affinity);
+      }
+      if (!ctx.has("clientVersion") && options?.fetchClientVersion !== false) {
+        await client.auth.fetchClientVersion().catch(() => void 0);
+      }
+    },
+    async events() {
+      return openEventStream(ctx);
+    }
+  };
+}
+function launchArgument(args, name) {
+  const prefix = `-${name}=`;
+  return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+async function openEventStream(ctx) {
+  let WebSocket;
+  try {
+    WebSocket = (await import("ws")).WebSocket;
+  } catch (cause) {
+    throw new ValorantError('The local event stream needs the optional "ws" package: npm install ws', { cause });
+  }
+  const socket = new WebSocket(`wss://127.0.0.1:${ctx.require("localPort")}`, {
+    headers: { Authorization: `Basic ${btoa(`riot:${ctx.require("localPassword")}`)}` },
+    rejectUnauthorized: false
+  });
+  const listeners = /* @__PURE__ */ new Set();
+  socket.on("message", (raw) => {
+    const text2 = raw.toString();
+    if (text2 === "") return;
+    const message = JSON.parse(text2);
+    if (!Array.isArray(message) || message[0] !== 8) return;
+    for (const listener of [...listeners]) listener(String(message[1]), message[2]);
+  });
+  await new Promise((resolve, reject) => {
+    socket.once("open", resolve);
+    socket.once("error", reject);
+  });
+  return {
+    onEvent(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    subscribe: (eventName) => socket.send(JSON.stringify([5, eventName])),
+    unsubscribe: (eventName) => socket.send(JSON.stringify([6, eventName])),
+    close: () => socket.close()
+  };
+}
+
+// src/request.ts
+var import_valorant_api_types11 = require("valorant-api-types");
+
+// src/types.ts
+function paramName(variable) {
+  const [first = "", ...rest] = variable.replaceAll("-", " ").split(" ");
+  return first.charAt(0).toLowerCase() + first.slice(1) + rest.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+
+// src/request.ts
+var AUTH_HOST = "auth.riotgames.com";
+function applyQuirks(path, ctx) {
+  const hardcoded = "/leaderboards/affinity/na/";
+  return path.includes(hardcoded) ? path.replace(hardcoded, `/leaderboards/affinity/${ctx.require("shard")}/`) : path;
+}
+function resolvePath(endpoint2, input, ctx) {
+  const suffix = applyQuirks(endpoint2.suffix, ctx);
+  return suffix.replace(/\{([^}]+)\}/g, (_, variable) => {
+    const name = paramName(variable);
+    const value = input.params?.[name] ?? (name === "puuid" || name === "region" ? ctx.require(name) : void 0);
+    if (value === void 0) throw new MissingParameterError(name, endpoint2.name);
+    return encodeURIComponent(value);
+  });
+}
+function resolveBase(endpoint2, ctx) {
+  switch (endpoint2.type) {
+    case "pd":
+    case "shared":
+      return (0, import_valorant_api_types11.typeToPrefix)({ type: endpoint2.type, shard: ctx.require("shard") });
+    case "glz":
+      return (0, import_valorant_api_types11.typeToPrefix)({ type: "glz", shard: ctx.require("shard"), region: ctx.require("region") });
+    case "local":
+      return (0, import_valorant_api_types11.typeToPrefix)({ type: "local", port: ctx.require("localPort") });
+    case "other":
+      return "";
+  }
+}
+function appendQuery(url, query2) {
+  if (!query2) return url;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query2)) {
+    if (value !== void 0 && value !== null) params.append(key, String(value));
+  }
+  const encoded = params.toString();
+  if (encoded === "") return url;
+  return url + (url.includes("?") ? "&" : "?") + encoded;
+}
+function resolveHeaders(endpoint2, input, ctx, url) {
+  const headers = { Accept: "application/json" };
+  const need = endpoint2.riotRequirements ?? {};
+  const userAgent = ctx.get("userAgent");
+  if (userAgent) headers["User-Agent"] = userAgent;
+  if (need.token) headers["Authorization"] = `Bearer ${ctx.require("accessToken")}`;
+  if (need.localAuth) headers["Authorization"] = `Basic ${btoa(`riot:${ctx.require("localPassword")}`)}`;
+  if (need.entitlement) headers["X-Riot-Entitlements-JWT"] = ctx.require("entitlementToken");
+  if (need.clientVersion) headers["X-Riot-ClientVersion"] = ctx.require("clientVersion");
+  if (need.clientPlatform) headers["X-Riot-ClientPlatform"] = ctx.require("clientPlatform");
+  for (const [name, value] of endpoint2.headers ?? []) headers[name] = value;
+  if (input.body !== void 0 && !Object.keys(headers).some((h) => h.toLowerCase() === "content-type")) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (new URL(url).hostname === AUTH_HOST) {
+    const cookie = ctx.cookieHeader();
+    if (cookie) headers["Cookie"] = cookie;
+  }
+  return { ...headers, ...input.headers };
+}
+function isAuthHost(url) {
+  return new URL(url).hostname === AUTH_HOST;
+}
+function buildRequest(endpoint2, input, ctx) {
+  const path = resolvePath(endpoint2, input, ctx);
+  const base = resolveBase(endpoint2, ctx);
+  const url = appendQuery(base + (base === "" ? path : path.replace(/^\/+/, "")), input.query);
+  const method = endpoint2.method ?? "GET";
+  const headers = resolveHeaders(endpoint2, input, ctx, url);
+  const declaresJson = [...endpoint2.headers?.keys() ?? []].some((h) => h.toLowerCase() === "content-type");
+  const body = input.body !== void 0 ? JSON.stringify(input.body) : method !== "GET" && declaresJson ? "{}" : void 0;
+  return { method, url, headers, body };
+}
+
+// src/client.ts
+var ValorantClient = class {
+  context;
+  #options;
+  #warned = /* @__PURE__ */ new Set();
+  #refreshing;
+  constructor(options = {}) {
+    this.#options = options;
+    this.context = options.context instanceof ValorantContext ? options.context : new ValorantContext(options.context);
+    Object.assign(this, this.#createApi());
+  }
+  /** Sends a request and returns status, headers and the parsed body. */
+  async send(endpoint2, options = {}) {
+    const input = options;
+    const validation = input.validation ?? this.#options.validation ?? "loose";
+    if (validation === "strict" && endpoint2.body !== void 0 && input.body !== void 0) {
+      const parsed = endpoint2.body.safeParse(input.body);
+      if (!parsed.success) throw new ValorantValidationError("request", endpoint2.name, parsed.error, input.body);
+    }
+    const retry = this.#options.retry === false ? void 0 : this.#options.retry ?? {};
+    const maxRetries = retry ? retry.retries ?? 2 : 0;
+    let refreshed = false;
+    for (let attempt = 0; ; attempt++) {
+      const request = buildRequest(endpoint2, input, this.context);
+      const canRetry = attempt < maxRetries && input.signal?.aborted !== true;
+      let response;
+      try {
+        response = await this.#transportFor(endpoint2)({ ...request, signal: this.#signal(input) });
+      } catch (cause) {
+        if (canRetry && 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)) storeCookies(this.context, response.setCookies);
+      this.#options.logger?.debug?.(`${request.method} ${request.url} -> ${response.status}`);
+      if (response.status < 400) {
+        return {
+          status: response.status,
+          headers: response.headers,
+          data: this.#parseResponse(endpoint2, response, validation)
+        };
+      }
+      const error = toApiError(endpoint2, request, response);
+      if (error instanceof ValorantAuthError && this.#options.refreshTokens && !refreshed) {
+        refreshed = true;
+        await this.#refreshOnce();
+        continue;
+      }
+      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;
+      }
+      throw error;
+    }
+  }
+  #createApi() {
+    const api = {};
+    for (const [group, endpoints] of Object.entries(registry)) {
+      api[group] = Object.fromEntries(Object.entries(endpoints).map(([name, endpoint2]) => [
+        name,
+        async (options) => (await this.send(endpoint2, options)).data
+      ]));
+    }
+    Object.assign(api["auth"], createAuthFlows(this));
+    Object.assign(api["local"], createLocalFlows(this));
+    return api;
+  }
+  #transportFor(endpoint2) {
+    if (endpoint2.type === "local") return this.#options.localTransport ?? localTransport;
+    return this.#options.transport ?? fetchTransport;
+  }
+  /** Transport used for requests to arbitrary remote hosts. */
+  get transport() {
+    return this.#options.transport ?? fetchTransport;
+  }
+  #signal(input) {
+    const timeout = AbortSignal.timeout(input.timeoutMs ?? this.#options.timeoutMs ?? 15e3);
+    return input.signal ? AbortSignal.any([input.signal, timeout]) : timeout;
+  }
+  #parseResponse(endpoint2, response, validation) {
+    const data = unwrapEnvelope(endpoint2, parseBody(response.text));
+    const schema = endpoint2.responses?.[String(response.status)];
+    if (schema === void 0 || validation === "off") return data;
+    const parsed = safeParse(schema, data);
+    if (parsed.success) return parsed.data;
+    if (validation === "strict") throw new ValorantValidationError("response", endpoint2.name, parsed.error, data);
+    if (!this.#warned.has(endpoint2.name)) {
+      this.#warned.add(endpoint2.name);
+      this.#options.logger?.warn(`Response of "${endpoint2.name}" does not match its schema, returning raw data`, parsed.error.issues.slice(0, 5));
+    }
+    return data;
+  }
+  #refreshOnce() {
+    this.#refreshing ??= Promise.resolve(this.#options.refreshTokens(this)).finally(() => {
+      this.#refreshing = void 0;
+    });
+    return this.#refreshing;
+  }
+};
+
+// src/index.ts
+__reExport(index_exports, require("valorant-api-types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MissingContextError,
+  MissingParameterError,
+  ValorantApiError,
+  ValorantAuthError,
+  ValorantClient,
+  ValorantContext,
+  ValorantError,
+  ValorantNetworkError,
+  ValorantRateLimitError,
+  ValorantValidationError,
+  fetchTransport,
+  isRegion,
+  localTransport,
+  parseAuthRedirect,
+  parseLockfile,
+  readLockfile,
+  registry,
+  shardForRegion,
+  ...require("valorant-api-types")
+});
+//# sourceMappingURL=index.cjs.map