uva-wrapper 4.9.0

package/src/account/index.ts

@@ -0,0 +1,12 @@
+import { v1_AccountCategory } from "./v1";
+import { v2_AccountCategory } from "./v2";
+
+export class AccountCategory {
+  constructor(public apiKey: string) {
+    this.v1 = new v1_AccountCategory(this.apiKey);
+    this.v2 = new v2_AccountCategory(this.apiKey);
+  }
+
+  v1: v1_AccountCategory;
+  v2: v2_AccountCategory;
+}

package/src/account/v1/getAccount.ts

@@ -0,0 +1,31 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v1_getAccount(
+  apiKey: string,
+  name: string,
+  tag: string,
+  force?: boolean,
+) {
+  return await doApiRequest<v1_getAccount_ResponseData>(
+    apiKey,
+    `/valorant/v1/account/${name}/${tag}`,
+    { force: force ? (force ? "true" : "false") : undefined },
+    { method: "GET" },
+  );
+}
+
+export interface v1_getAccount_ResponseData {
+  account_level: number;
+  card: {
+    id: string;
+    large: string;
+    small: string;
+    wide: string;
+  };
+  last_update: string;
+  last_update_raw: number;
+  name: string;
+  puuid: string;
+  region: string;
+  tag: string;
+}

package/src/account/v1/getAccountByPuuid.ts

@@ -0,0 +1,30 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v1_getAccountByPuuid(
+  apiKey: string,
+  puuid: string,
+  force?: boolean,
+) {
+  return doApiRequest<v1_getAccountByPuuid_ResponseData>(
+    apiKey,
+    `/valorant/v1/by-puuid/account/${puuid}`,
+    { force: force ? (force ? "true" : "false") : undefined },
+    { method: "GET" },
+  );
+}
+
+export interface v1_getAccountByPuuid_ResponseData {
+  account_level: number;
+  card: {
+    id: string;
+    large: string;
+    small: string;
+    wide: string;
+  };
+  last_update: string;
+  last_update_raw: number;
+  name: string;
+  puuid: string;
+  region: string;
+  tag: string;
+}

package/src/account/v1/index.ts

@@ -0,0 +1,27 @@
+import { v1_getAccount } from "./getAccount";
+import { v1_getAccountByPuuid } from "./getAccountByPuuid";
+
+export class v1_AccountCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-account-by-puuid-v1
+   * @param puuid Player UUID
+   * @param force Bypass cache and refresh (optional)
+   * @returns Account data retrieved successfully
+   */
+  async getByPuuid(puuid: string, force?: boolean) {
+    return await v1_getAccountByPuuid(this.apiKey, puuid, force);
+  }
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-account-v1
+   * @param name Riot ID name
+   * @param tag Riot ID tag
+   * @param force Bypass cache and refresh (optional)
+   * @returns Account data retrieved successfully
+   */
+  async get(name: string, tag: string, force?: boolean) {
+    return await v1_getAccount(this.apiKey, name, tag, force);
+  }
+}

package/src/account/v2/getAccount.ts

@@ -0,0 +1,27 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v2_getAccount(
+  apiKey: string,
+  name: string,
+  tag: string,
+  force?: boolean,
+) {
+  return await doApiRequest<v2_getAccount_ResponseData>(
+    apiKey,
+    `/valorant/v2/account/${name}/${tag}`,
+    { force: force ? (force ? "true" : "false") : undefined },
+    { method: "GET" },
+  );
+}
+
+export interface v2_getAccount_ResponseData {
+  account_level: number;
+  card: string;
+  name: string;
+  platforms: string[];
+  puuid: string;
+  region: string;
+  tag: string;
+  title: string;
+  updated_at: string;
+}

package/src/account/v2/getAccountByPuuid.ts

@@ -0,0 +1,26 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v2_getAccountByPuuid(
+  apiKey: string,
+  puuid: string,
+  force?: boolean,
+) {
+  return doApiRequest<v2_getAccountByPuuid_ResponseData>(
+    apiKey,
+    `/valorant/v2/by-puuid/account/${puuid}`,
+    { force: force ? (force ? "true" : "false") : undefined },
+    { method: "GET" },
+  );
+}
+
+export interface v2_getAccountByPuuid_ResponseData {
+  account_level: number;
+  card: string;
+  name: string;
+  platforms: string[];
+  puuid: string;
+  region: string;
+  tag: string;
+  title: string;
+  updated_at: string;
+}

package/src/account/v2/index.ts

@@ -0,0 +1,27 @@
+import { v2_getAccount } from "./getAccount";
+import { v2_getAccountByPuuid } from "./getAccountByPuuid";
+
+export class v2_AccountCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-account-v2
+   * @param name Riot ID name
+   * @param tag Riot ID tag
+   * @param force Bypass cache and refresh (optional)
+   * @returns Account data retrieved successfully
+   */
+  async get(name: string, tag: string, force?: boolean) {
+    return await v2_getAccount(this.apiKey, name, tag, force);
+  }
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-account-by-puuid-v2
+   * @param puuid Player UUID
+   * @param force Bypass cache and refresh (optional)
+   * @returns Account data retrieved successfully
+   */
+  async getByPuuid(puuid: string, force?: boolean) {
+    return await v2_getAccountByPuuid(this.apiKey, puuid, force);
+  }
+}

package/src/constants/api.const.ts

@@ -0,0 +1 @@
+export const apiURL = "https://api.henrikdev.xyz";

package/src/crosshair/index.ts

@@ -0,0 +1,9 @@
+import { v1_CrosshairCategory } from "./v1";
+
+export class CrosshairCategory {
+  constructor(private readonly apiKey: string) {
+    this.v1 = new v1_CrosshairCategory(this.apiKey);
+  }
+
+  v1: v1_CrosshairCategory;
+}

package/src/crosshair/v1/generateCrosshairImage.ts

@@ -0,0 +1,10 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v1_generateCrosshairImage(apiKey: string, id?: string) {
+  return await doApiRequest(
+    apiKey,
+    "/valorant/v1/crosshair/generate",
+    { id },
+    { method: "GET" },
+  );
+}

package/src/crosshair/v1/index.ts

@@ -0,0 +1,14 @@
+import { v1_generateCrosshairImage } from "./generateCrosshairImage";
+
+export class v1_CrosshairCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/generate-crosshair-image-v1
+   * @param id Crosshair code
+   * @returns Crosshair image generated successfully
+   */
+  async generateImage(id?: string) {
+    return await v1_generateCrosshairImage(this.apiKey, id);
+  }
+}

package/src/esports/index.ts

@@ -0,0 +1,9 @@
+import { v1_EsportsCategory } from "./v1";
+
+export class EsportsCategory {
+  constructor(private readonly apiKey: string) {
+    this.v1 = new v1_EsportsCategory(this.apiKey);
+  }
+
+  v1: v1_EsportsCategory;
+}

package/src/esports/v1/getEsportsSchedule.ts

@@ -0,0 +1,49 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v1_getEsportsSchedule(
+  apiKey: string,
+  region?: string,
+  league?: string,
+) {
+  return await doApiRequest<v1_getEsportsSchedule_ResponseData[]>(
+    apiKey,
+    "/valorant/v1/esports/schedule",
+    { region, league },
+    { method: "GET" },
+  );
+}
+
+export interface v1_getEsportsSchedule_ResponseData {
+  date: string;
+  league: {
+    icon: string;
+    identifier: string;
+    name: string;
+    region: string;
+  };
+  match: {
+    game_type: {
+      count: number;
+      type: string;
+    };
+    teams: {
+      code: string;
+      game_wins: number;
+      has_won: boolean;
+      icon: string;
+      name: string;
+      record: {
+        losses: number;
+        wins: number;
+      };
+    }[];
+    id: string;
+  };
+  state: string;
+  tournament: {
+    name: string;
+    season: string;
+  };
+  type: string;
+  vod: string;
+}

package/src/esports/v1/index.ts

@@ -0,0 +1,15 @@
+import { v1_getEsportsSchedule } from "./getEsportsSchedule";
+
+export class v1_EsportsCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-esports-schedule-v1
+   * @param region
+   * @param league
+   * @returns Esports schedule retrieved successfully
+   */
+  async getSchedule(region?: string, league?: string) {
+    return await v1_getEsportsSchedule(this.apiKey, region, league);
+  }
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+import { AccountCategory } from "./account";
+import { CrosshairCategory } from "./crosshair";
+import { EsportsCategory } from "./esports";
+import { LeaderboardCategory } from "./leaderboard";
+import { MatchDetailsCategory } from "./match-details";
+import { MatchesCategory } from "./matches";
+import { MiscCategory } from "./misc";
+import { MMRCategory } from "./mmr";
+import { MMRHistoryCategory } from "./mmr-history";
+import { PremierCategory } from "./premier";
+import { PremierHistoryCategory } from "./premier-history";
+import { PremierLeaderboardCategory } from "./premier-leaderboard";
+import { PremiumCategory } from "./premium";
+import { StoreCategory } from "./store";
+import { StoredMatchesCategory } from "./stored-matches";
+import { StoredMMRHistoryCategory } from "./stored-mmr-history";
+import { VlrCategory } from "./vlr";
+
+export class UnofficialValorantAPI {
+  constructor(private readonly apiKey: string) {
+    this.Account = new AccountCategory(this.apiKey);
+    this.Crosshair = new CrosshairCategory(this.apiKey);
+    this.Esports = new EsportsCategory(this.apiKey);
+    this.Leaderboard = new LeaderboardCategory(this.apiKey);
+    this.Match_Details = new MatchDetailsCategory(this.apiKey);
+    this.Matches = new MatchesCategory(this.apiKey);
+    this.Misc = new MiscCategory(this.apiKey);
+    this.MMR = new MMRCategory(this.apiKey);
+    this.MMR_History = new MMRHistoryCategory(this.apiKey);
+    this.Premier = new PremierCategory(this.apiKey);
+    this.Premier_History = new PremierHistoryCategory(this.apiKey);
+    this.Premier_Leaderboard = new PremierLeaderboardCategory(this.apiKey);
+    this.Premium = new PremiumCategory(this.apiKey);
+    this.Store = new StoreCategory(this.apiKey);
+    this.Stored_Matches = new StoredMatchesCategory(this.apiKey);
+    this.Stored_MMR_History = new StoredMMRHistoryCategory(this.apiKey);
+    this.Vlr = new VlrCategory(this.apiKey);
+  }
+
+  Account: AccountCategory;
+  Crosshair: CrosshairCategory;
+  Esports: EsportsCategory;
+  Leaderboard: LeaderboardCategory;
+  Match_Details: MatchDetailsCategory;
+  Matches: MatchesCategory;
+  Misc: MiscCategory;
+  MMR: MMRCategory;
+  MMR_History: MMRHistoryCategory;
+  Premier: PremierCategory;
+  Premier_History: PremierHistoryCategory;
+  Premier_Leaderboard: PremierLeaderboardCategory;
+  Premium: PremiumCategory;
+  Store: StoreCategory;
+  Stored_Matches: StoredMatchesCategory;
+  Stored_MMR_History: StoredMMRHistoryCategory;
+  Vlr: VlrCategory;
+}

package/src/leaderboard/index.ts

@@ -0,0 +1,15 @@
+import { v1_LeaderboardCategory } from "./v1";
+import { v2_LeaderboardCategory } from "./v2";
+import { v3_LeaderboardCategory } from "./v3";
+
+export class LeaderboardCategory {
+  constructor(private readonly apiKey: string) {
+    this.v1 = new v1_LeaderboardCategory(this.apiKey);
+    this.v2 = new v2_LeaderboardCategory(this.apiKey);
+    this.v3 = new v3_LeaderboardCategory(this.apiKey);
+  }
+
+  v1: v1_LeaderboardCategory;
+  v2: v2_LeaderboardCategory;
+  v3: v3_LeaderboardCategory;
+}

package/src/leaderboard/v1/getLeaderboard.ts

@@ -0,0 +1,17 @@
+import { doApiRequest } from "../../lib/request-handler";
+
+export async function v1_getLeaderboard(
+  apiKey: string,
+  affinity: string,
+  season?: string,
+  name?: string,
+  tag?: string,
+) {
+  return await doApiRequest<unknown>(
+    apiKey,
+    `/valorant/v1/leaderboard/${affinity}`,
+    { season, name, tag },
+    { method: "GET" },
+  );
+}
+export interface v1_getLeaderboard_ResponseData {}

package/src/leaderboard/v1/index.ts

@@ -0,0 +1,17 @@
+import { v1_getLeaderboard } from "./getLeaderboard";
+
+export class v1_LeaderboardCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-leaderboard-v1
+   * @param affinity Region/affinity (e.g., na, eu, ap, kr)
+   * @param season Season ID (optional)
+   * @param name Player name to search for (optional)
+   * @param tag Player tag to search for (optional)
+   * @returns Leaderboard retrieved successfully
+   */
+  async get(affinity: string, season?: string, name?: string, tag?: string) {
+    return await v1_getLeaderboard(this.apiKey, affinity, season, name, tag);
+  }
+}

package/src/leaderboard/v2/getLeaderboard.ts

@@ -0,0 +1,40 @@
+import { doApiRequest } from "../../lib/request-handler";
+import { DefaultErrorsResponse } from "../../types/response.type";
+
+export async function v2_getLeaderboard(
+  apiKey: string,
+  affinity: string,
+  season?: string,
+  name?: string,
+  tag?: string,
+  puuid?: string,
+) {
+  return (await doApiRequest(
+    apiKey,
+    `/valorant/v2/leaderboard/${affinity}`,
+    { season, name, tag, puuid },
+    { method: "GET" },
+  )) as v2_getLeaderboard_ResponseData | DefaultErrorsResponse;
+}
+export interface v2_getLeaderboard_ResponseData {
+  immortal_1_threshold: number;
+  immortal_2_threshold: number;
+  immortal_3_threshold: number;
+  last_update: number;
+  next_update: number;
+  players: {
+    IsAnonymized: boolean;
+    IsBanned: boolean;
+    PlayerCardID: string;
+    TitleID: string;
+    competitiveTier: number;
+    gameName: string;
+    leaderboardRank: number;
+    numberOfWins: number;
+    rankedRating: number;
+    tagLine: string;
+    puuid: string | null;
+  }[];
+  radiant_threshold: number;
+  total_players: number;
+}

package/src/leaderboard/v2/index.ts

@@ -0,0 +1,31 @@
+import { v2_getLeaderboard } from "./getLeaderboard";
+
+export class v2_LeaderboardCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-leaderboard-v2
+   * @param affinity Region/affinity (e.g., na, eu, ap, kr)
+   * @param season Season ID (optional)
+   * @param name Player name to search for (optional)
+   * @param tag Player tag to search for (optional)
+   * @param puuid Player UUID to search for (optional)
+   * @returns Leaderboard retrieved successfully
+   */
+  async get(
+    affinity: string,
+    season?: string,
+    name?: string,
+    tag?: string,
+    puuid?: string,
+  ) {
+    return await v2_getLeaderboard(
+      this.apiKey,
+      affinity,
+      season,
+      name,
+      tag,
+      puuid,
+    );
+  }
+}

package/src/leaderboard/v3/getLeaderboard.ts

@@ -0,0 +1,57 @@
+import { doApiRequest } from "../../lib/request-handler";
+import {
+  DefaultApiResponse,
+  DefaultErrorsResponse,
+} from "../../types/response.type";
+
+export async function v3_getLeaderboard(
+  apiKey: string,
+  affinity: string,
+  platform: string,
+  season?: string,
+  size?: number,
+  page?: number,
+  name?: string,
+  tag?: string,
+) {
+  return (await doApiRequest(
+    apiKey,
+    `/valorant/v3/leaderboard/${affinity}/${platform}`,
+    { season, size: size?.toString(), page: page?.toString(), name, tag },
+    { method: "GET" },
+  )) as
+    | (DefaultApiResponse<v3_getLeaderboard_ResponseData> & {
+        results: {
+          after: number;
+          before: number;
+          returned: number;
+          total: number;
+        };
+      })
+    | DefaultErrorsResponse;
+}
+export interface v3_getLeaderboard_ResponseData {
+  players: {
+    card: string;
+    is_anonymized: boolean;
+    is_banned: boolean;
+    leaderboard_rank: number;
+    name: string;
+    rr: number;
+    tag: string;
+    tier: number;
+    title: string;
+    updated_at: string;
+    wins: number;
+    puuid: string | null;
+  }[];
+  thresholds: {
+    start_index: number;
+    threshold: number;
+    tier: {
+      id: number;
+      name: string;
+    };
+  }[];
+  updated_at: string;
+}

package/src/leaderboard/v3/index.ts

@@ -0,0 +1,37 @@
+import { v3_getLeaderboard } from "./getLeaderboard";
+
+export class v3_LeaderboardCategory {
+  constructor(private readonly apiKey: string) {}
+
+  /**
+   * @link https://docs.henrikdev.xyz/api-reference/valorant/get-leaderboard-v3
+   * @param affinity Region/affinity (e.g., na, eu, ap, kr)
+   * @param platform Platform (pc, console)
+   * @param season Season ID (optional)
+   * @param size Number of results per page (optional)
+   * @param page Page number (optional)
+   * @param name Player name to search for (optional)
+   * @param tag Player tag to search for (optional)
+   * @returns Leaderboard retrieved successfully
+   */
+  async get(
+    affinity: string,
+    platform: string,
+    season?: string,
+    size?: number,
+    page?: number,
+    name?: string,
+    tag?: string,
+  ) {
+    return await v3_getLeaderboard(
+      this.apiKey,
+      affinity,
+      platform,
+      season,
+      size,
+      page,
+      name,
+      tag,
+    );
+  }
+}

package/src/lib/request-handler.ts

@@ -0,0 +1,29 @@
+import { apiURL } from "../constants/api.const";
+import {
+  DefaultApiResponse,
+  DefaultErrorsResponse,
+} from "../types/response.type";
+
+export async function doApiRequest<T>(
+  apiKey: string,
+  url: string,
+  query?: Record<string, string | undefined>,
+  init?: RequestInit & { method: "GET" | "POST" | "PUT" | "DELETE" },
+): Promise<DefaultApiResponse<T> | DefaultErrorsResponse> {
+  return await fetch(
+    apiURL + url + Object.entries(query || {}).length
+      ? "?"
+      : "" +
+          Object.entries(query || {})
+            .filter((e) => typeof e[1] === "string")
+            .map((e) => e[0] + "=" + e[1]!.toString())
+            .join("&"),
+    {
+      ...init,
+      headers: {
+        ...init?.headers,
+        Authorization: apiKey,
+      },
+    },
+  ).then((res) => res.json());
+}

package/src/match-details/index.ts

@@ -0,0 +1,12 @@
+import { v2_MatchDetailsCategory } from "./v2";
+import { v4_MatchDetailsCategory } from "./v4";
+
+export class MatchDetailsCategory {
+  constructor(private readonly apiKey: string) {
+    this.v2 = new v2_MatchDetailsCategory(this.apiKey);
+    this.v4 = new v4_MatchDetailsCategory(this.apiKey);
+  }
+
+  v2: v2_MatchDetailsCategory;
+  v4: v4_MatchDetailsCategory;
+}