uva-wrapper 4.9.0

package/dist/vlr/v2/getVlrEventMatches.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrEventMatches = v2_getVlrEventMatches;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrEventMatches(apiKey, eventId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/events/${eventId}/matches`, {}, { method: "GET" });
+    });
+}

package/dist/vlr/v2/getVlrMatchDetails.d.ts

@@ -0,0 +1,157 @@
+export declare function v2_getVlrMatchDetails(apiKey: string, matchId: number): Promise<import("../../types/response.type").DefaultApiResponse<v2_getVlrMatchDetails_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v2_getVlrMatchDetails_ResponseData {
+    games: {
+        map: string;
+        rounds: {
+            round: number;
+            winning_site: string;
+            winning_team: number;
+        }[];
+        teams: {
+            is_winner: boolean;
+            name: string;
+            players: {
+                agent: string;
+                player: {
+                    id: number;
+                    name: string;
+                    nation: string;
+                    slug: string;
+                };
+                stats: {
+                    acs: number | null;
+                    adr: number | null;
+                    assists: number | null;
+                    deaths: number | null;
+                    first_deaths: number | null;
+                    first_kills: number | null;
+                    fk_diff: number | null;
+                    hs_pct: number | null;
+                    kast: number | null;
+                    kd_diff: number | null;
+                    kills: number | null;
+                    rating: number | null;
+                };
+            }[];
+            score: number | null;
+            score_ct: number | null;
+            score_t: number | null;
+        }[];
+        duration_in_s: number | null;
+        picked_by: number | null;
+    }[];
+    head_to_head: {
+        date: string;
+        event: {
+            icon: string;
+            name: string;
+            series: string;
+        };
+        match: {
+            id: number;
+            slug: string;
+        };
+        score: {
+            team_1: number;
+            team_2: number;
+            winner_team: number;
+        };
+    }[];
+    metadata: {
+        date: string;
+        event: {
+            icon: string;
+            id: number;
+            series: string;
+            slug: string;
+            title: string;
+        };
+        format: string;
+        note: string;
+        patch: string;
+        status: string;
+    };
+    past_matches: {
+        matches: {
+            date: string;
+            is_win: boolean;
+            match: {
+                id: number;
+                slug: string;
+            };
+            opponent: {
+                logo: string;
+                name: string;
+            };
+            score: {
+                against: number;
+                for: number;
+            };
+        }[];
+        team: number;
+    }[];
+    streams: {
+        link: string;
+        name: string;
+    }[];
+    teams: {
+        icon: string;
+        id: number;
+        name: string;
+        slug: string;
+        url: string;
+        score: number | null;
+    }[];
+    vods: {
+        link: string;
+        name: string;
+    }[];
+    economy: {
+        teams: {
+            eco: {
+                rounds: number;
+                won: number;
+            };
+            full_buy: {
+                rounds: number;
+                won: number;
+            };
+            pistol_won: number;
+            semi_eco: {
+                rounds: number;
+                won: number;
+            };
+            team_name: string;
+        }[];
+    } | null;
+    performance: {
+        kill_matrix: {
+            deaths: number;
+            killer: number;
+            kills: number;
+            victim: number;
+        }[];
+        player_performances: {
+            clutches: {
+                "1v1": number;
+                "1v2": number;
+                "1v3": number;
+                "1v4": number;
+                "1v5": number;
+            };
+            defuses: number;
+            econ_rating: number;
+            multi_kills: {
+                "2k": number;
+                "3k": number;
+                "4k": number;
+                "5k": number;
+            };
+            plants: number;
+            player: {
+                id: number;
+                name: string;
+            };
+        }[];
+    } | null;
+}

package/dist/vlr/v2/getVlrMatchDetails.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrMatchDetails = v2_getVlrMatchDetails;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrMatchDetails(apiKey, matchId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/matches/${matchId}`, {}, { method: "GET" });
+    });
+}

package/dist/vlr/v2/getVlrPlayer.d.ts

@@ -0,0 +1,64 @@
+export declare function v2_getVlrPlayer(apiKey: string, player: number, timespan?: "30d" | "60d" | "90d" | "all"): Promise<import("../../types/response.type").DefaultApiResponse<unknown> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v2_getVlrPlayer_ResponseData {
+    agent_stats: {
+        agent: string;
+        stats: {
+            acs: number;
+            adr: number;
+            apr: number;
+            assists: number;
+            deaths: number;
+            fdpr: number;
+            first_deaths: number;
+            first_kills: number;
+            fkpr: number;
+            kast: number;
+            kd: number;
+            kills: number;
+            kpr: number;
+            rating: number;
+        };
+        usage: {
+            count: number;
+            percentage: number;
+            rounds: number;
+        };
+    }[];
+    current_teams: {
+        id: number;
+        logo: string;
+        name: string;
+    }[];
+    event_placements: {
+        event: {
+            id: number;
+            name: string;
+            slug: string;
+        };
+        placements: {
+            placement: string;
+            stage: string;
+            prize: string;
+            team: string;
+        }[];
+        year: string;
+    }[];
+    id: number;
+    name: string;
+    past_teams: {
+        id: number;
+        logo: string;
+        name: string;
+    }[];
+    socials: {
+        platform: string;
+        url: string;
+    }[];
+    avatar: string;
+    country: {
+        code: string;
+        name: string;
+    };
+    real_name: string;
+    total_winnings: string;
+}

package/dist/vlr/v2/getVlrPlayer.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrPlayer = v2_getVlrPlayer;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrPlayer(apiKey, player, timespan) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/players/${player}`, { timespan }, { method: "GET" });
+    });
+}

package/dist/vlr/v2/getVlrPlayerMatches.d.ts

@@ -0,0 +1,22 @@
+export declare function v2_getVlrPlayerMatches(apiKey: string, player: number, page?: number): Promise<import("../../types/response.type").DefaultApiResponse<v2_getVlrPlayerMatches_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v2_getVlrPlayerMatches_ResponseData {
+    league: {
+        icon: string;
+        name: string;
+        series: string;
+    };
+    match: {
+        id: number;
+        slug: string;
+    };
+    teams: [
+        {
+            icon: string;
+            name: string;
+            tag: string;
+            score: number | null;
+        }
+    ];
+    vods: string[];
+    date: string | null;
+}

package/dist/vlr/v2/getVlrPlayerMatches.js

@@ -0,0 +1,20 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrPlayerMatches = v2_getVlrPlayerMatches;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrPlayerMatches(apiKey, player, page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/players/${player}/matches`, {
+            page: page === null || page === void 0 ? void 0 : page.toString(),
+        });
+    });
+}

package/dist/vlr/v2/getVlrTeam.d.ts

@@ -0,0 +1,39 @@
+export declare function v2_getVlrTeam(apiKey: string, teamId: number): Promise<import("../../types/response.type").DefaultApiResponse<v2_getVlrTeam_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v2_getVlrTeam_ResponseData {
+    event_placements: {
+        event: {
+            id: number;
+            name: string;
+            slug: string;
+        };
+        placements: {
+            placement: string;
+            stage: string;
+            prize: string | null;
+            team: string | null;
+        }[];
+        year: string;
+    }[];
+    id: number;
+    name: string;
+    roster: {
+        alias: string;
+        id: number;
+        is_captain: boolean;
+        role: string;
+        avatar: string | null;
+        country_code: string | null;
+        real_name: string | null;
+    }[];
+    socials: {
+        platform: string;
+        url: string;
+    }[];
+    country: {
+        code: string;
+        name: string;
+    } | null;
+    logo: string | null;
+    tag: string | null;
+    total_winnings: string | null;
+}

package/dist/vlr/v2/getVlrTeam.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrTeam = v2_getVlrTeam;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrTeam(apiKey, teamId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/teams/${teamId}`, {}, { method: "GET" });
+    });
+}

package/dist/vlr/v2/getVlrTeamMatches.d.ts

@@ -0,0 +1,20 @@
+export declare function v2_getVlrTeamMatches(apiKey: string, teamId: number, page?: number): Promise<import("../../types/response.type").DefaultApiResponse<v2_getVlrTeamMatches_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v2_getVlrTeamMatches_ResponseData {
+    league: {
+        icon: string;
+        name: string;
+        series: string;
+    };
+    match: {
+        id: number;
+        slug: string;
+    };
+    teams: {
+        logo: string;
+        name: string;
+        tag: string;
+        score: number;
+    }[];
+    vods: string[];
+    date: string;
+}

package/dist/vlr/v2/getVlrTeamMatches.js

@@ -0,0 +1,20 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrTeamMatches = v2_getVlrTeamMatches;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrTeamMatches(apiKey, teamId, page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/teams/${teamId}/matches`, {
+            page: page === null || page === void 0 ? void 0 : page.toString(),
+        });
+    });
+}

package/dist/vlr/v2/getVlrTeamTransactions.d.ts

@@ -0,0 +1,14 @@
+export declare function v2_getVlrTeamTransactions(apiKey: string, teamId: number): Promise<import("../../types/response.type").DefaultApiResponse<v2_getVlrTeamTransactions_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v2_getVlrTeamTransactions_ResponseData {
+    action: string;
+    player: {
+        alias: string;
+        id: number;
+        slug: string;
+        country_code: string;
+        real_name: string;
+    };
+    position: string;
+    date: string;
+    reference_url: string;
+}

package/dist/vlr/v2/getVlrTeamTransactions.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_getVlrTeamTransactions = v2_getVlrTeamTransactions;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getVlrTeamTransactions(apiKey, teamId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/esports/vlr/teams/${teamId}/transactions`);
+    });
+}

package/dist/vlr/v2/index.d.ts

@@ -0,0 +1,57 @@
+export declare class v2_VlrCategory {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-esports-events-v2
+     * @param region
+     * @param type
+     * @param page
+     * @returns Esports events retrieved successfully
+     */
+    getEsportsEvents(region?: "north_america" | "europe" | "brazil" | "asia_pacific" | "korea" | "japan" | "latin_america" | "oceania" | "mena" | "gc" | "collegiate", type?: "completed" | "upcoming", page?: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrEsportsEvents").v2_getVlrEsportsEvents_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-event-matches-v2
+     * @param eventId
+     * @returns Esports event matches retrieved successfully
+     */
+    getEventMatches(eventId: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrEventMatches").v2_getVlrEventMatches_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-match-details-v2
+     * @param matchId
+     * @returns Esports match details retrieved successfully
+     */
+    getMatchDetails(matchId: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrMatchDetails").v2_getVlrMatchDetails_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-team-v2
+     * @param teamId
+     * @returns Esports team profile retrieved successfully
+     */
+    getTeam(teamId: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrTeam").v2_getVlrTeam_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-team-matches-v2
+     * @param teamId
+     * @param page
+     * @returns Esports team matches retrieved successfully
+     */
+    getTeamMatches(teamId: number, page?: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrTeamMatches").v2_getVlrTeamMatches_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-team-transactions-v2
+     * @param teamId
+     * @returns Esports team transactions retrieved successfully
+     */
+    getTeamTransactions(teamId: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrTeamTransactions").v2_getVlrTeamTransactions_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-player-v2
+     * @param player
+     * @param timespan
+     * @returns Esports player profile retrieved successfully
+     */
+    getPlayer(player: number, timespan?: "30d" | "60d" | "90d" | "all"): Promise<import("../../types/response.type").DefaultApiResponse<unknown> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-player-matches-v2
+     * @param player
+     * @param page
+     * @returns Esports player matches retrieved successfully
+     */
+    getPlayerMatches(player: number, page?: number): Promise<import("../../types/response.type").DefaultApiResponse<import("./getVlrPlayerMatches").v2_getVlrPlayerMatches_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+}

package/dist/vlr/v2/index.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2_VlrCategory = void 0;
+const getVlrEsportsEvents_1 = require("./getVlrEsportsEvents");
+const getVlrEventMatches_1 = require("./getVlrEventMatches");
+const getVlrMatchDetails_1 = require("./getVlrMatchDetails");
+const getVlrPlayer_1 = require("./getVlrPlayer");
+const getVlrPlayerMatches_1 = require("./getVlrPlayerMatches");
+const getVlrTeam_1 = require("./getVlrTeam");
+const getVlrTeamMatches_1 = require("./getVlrTeamMatches");
+const getVlrTeamTransactions_1 = require("./getVlrTeamTransactions");
+class v2_VlrCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-esports-events-v2
+     * @param region
+     * @param type
+     * @param page
+     * @returns Esports events retrieved successfully
+     */
+    getEsportsEvents(region, type, page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrEsportsEvents_1.v2_getVlrEsportsEvents)(this.apiKey, region, type, page);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-event-matches-v2
+     * @param eventId
+     * @returns Esports event matches retrieved successfully
+     */
+    getEventMatches(eventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrEventMatches_1.v2_getVlrEventMatches)(this.apiKey, eventId);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-match-details-v2
+     * @param matchId
+     * @returns Esports match details retrieved successfully
+     */
+    getMatchDetails(matchId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrMatchDetails_1.v2_getVlrMatchDetails)(this.apiKey, matchId);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-team-v2
+     * @param teamId
+     * @returns Esports team profile retrieved successfully
+     */
+    getTeam(teamId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrTeam_1.v2_getVlrTeam)(this.apiKey, teamId);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-team-matches-v2
+     * @param teamId
+     * @param page
+     * @returns Esports team matches retrieved successfully
+     */
+    getTeamMatches(teamId, page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrTeamMatches_1.v2_getVlrTeamMatches)(this.apiKey, teamId, page);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-team-transactions-v2
+     * @param teamId
+     * @returns Esports team transactions retrieved successfully
+     */
+    getTeamTransactions(teamId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrTeamTransactions_1.v2_getVlrTeamTransactions)(this.apiKey, teamId);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-player-v2
+     * @param player
+     * @param timespan
+     * @returns Esports player profile retrieved successfully
+     */
+    getPlayer(player, timespan) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrPlayer_1.v2_getVlrPlayer)(this.apiKey, player, timespan);
+        });
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-vlr-player-matches-v2
+     * @param player
+     * @param page
+     * @returns Esports player matches retrieved successfully
+     */
+    getPlayerMatches(player, page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getVlrPlayerMatches_1.v2_getVlrPlayerMatches)(this.apiKey, player, page);
+        });
+    }
+}
+exports.v2_VlrCategory = v2_VlrCategory;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "uva-wrapper",
+  "version": "4.9.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "yarn && tsc"
+  },
+  "keywords": [
+    "valorant",
+    "unofficial-valorant-api",
+    "api",
+    "wrapper"
+  ],
+  "homepage": "https://github.com/leontm-dev/uva-wrapper",
+  "author": {
+    "email": "lanneken09@gmail.com",
+    "name": "LeonTM",
+    "url": "https://leontm.me"
+  },
+  "license": "MIT",
+  "description": "A type-safe API wrapper for Hendrik3's unofficial-valorant-api",
+  "dependencies": {},
+  "bugs": {
+    "email": "lanneken09@gmail.com",
+    "url": "https://github.com/leontm-dev/uva-wrapper/issues"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.4.1",
+    "@types/node": "^26.1.1",
+    "jest": "^30.4.2",
+    "ts-node": "^10.9.2",
+    "typescript": "7.0.2"
+  },
+  "readme": "https://github.com/leontm-dev/uva-wrapper/blob/main/README.md"
+}