uva-wrapper 4.9.0

package/dist/account/index.d.ts

@@ -0,0 +1,8 @@
+import { v1_AccountCategory } from "./v1";
+import { v2_AccountCategory } from "./v2";
+export declare class AccountCategory {
+    apiKey: string;
+    constructor(apiKey: string);
+    v1: v1_AccountCategory;
+    v2: v2_AccountCategory;
+}

package/dist/account/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountCategory = void 0;
+const v1_1 = require("./v1");
+const v2_1 = require("./v2");
+class AccountCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.v1 = new v1_1.v1_AccountCategory(this.apiKey);
+        this.v2 = new v2_1.v2_AccountCategory(this.apiKey);
+    }
+}
+exports.AccountCategory = AccountCategory;

package/dist/account/v1/getAccount.d.ts

@@ -0,0 +1,16 @@
+export declare function v1_getAccount(apiKey: string, name: string, tag: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<v1_getAccount_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+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/dist/account/v1/getAccount.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.v1_getAccount = v1_getAccount;
+const request_handler_1 = require("../../lib/request-handler");
+function v1_getAccount(apiKey, name, tag, force) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v1/account/${name}/${tag}`, { force: force ? (force ? "true" : "false") : undefined }, { method: "GET" });
+    });
+}

package/dist/account/v1/getAccountByPuuid.d.ts

@@ -0,0 +1,16 @@
+export declare function v1_getAccountByPuuid(apiKey: string, puuid: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<v1_getAccountByPuuid_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+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/dist/account/v1/getAccountByPuuid.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.v1_getAccountByPuuid = v1_getAccountByPuuid;
+const request_handler_1 = require("../../lib/request-handler");
+function v1_getAccountByPuuid(apiKey, puuid, force) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v1/by-puuid/account/${puuid}`, { force: force ? (force ? "true" : "false") : undefined }, { method: "GET" });
+    });
+}

package/dist/account/v1/index.d.ts

@@ -0,0 +1,19 @@
+export declare class v1_AccountCategory {
+    private readonly apiKey;
+    constructor(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
+     */
+    getByPuuid(puuid: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<import("./getAccountByPuuid").v1_getAccountByPuuid_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @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
+     */
+    get(name: string, tag: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<import("./getAccount").v1_getAccount_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+}

package/dist/account/v1/index.js

@@ -0,0 +1,43 @@
+"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.v1_AccountCategory = void 0;
+const getAccount_1 = require("./getAccount");
+const getAccountByPuuid_1 = require("./getAccountByPuuid");
+class v1_AccountCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * @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
+     */
+    getByPuuid(puuid, force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getAccountByPuuid_1.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
+     */
+    get(name, tag, force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getAccount_1.v1_getAccount)(this.apiKey, name, tag, force);
+        });
+    }
+}
+exports.v1_AccountCategory = v1_AccountCategory;

package/dist/account/v2/getAccount.d.ts

@@ -0,0 +1,12 @@
+export declare function v2_getAccount(apiKey: string, name: string, tag: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<v2_getAccount_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+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/dist/account/v2/getAccount.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_getAccount = v2_getAccount;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getAccount(apiKey, name, tag, force) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/account/${name}/${tag}`, { force: force ? (force ? "true" : "false") : undefined }, { method: "GET" });
+    });
+}

package/dist/account/v2/getAccountByPuuid.d.ts

@@ -0,0 +1,12 @@
+export declare function v2_getAccountByPuuid(apiKey: string, puuid: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<v2_getAccountByPuuid_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+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/dist/account/v2/getAccountByPuuid.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_getAccountByPuuid = v2_getAccountByPuuid;
+const request_handler_1 = require("../../lib/request-handler");
+function v2_getAccountByPuuid(apiKey, puuid, force) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, request_handler_1.doApiRequest)(apiKey, `/valorant/v2/by-puuid/account/${puuid}`, { force: force ? (force ? "true" : "false") : undefined }, { method: "GET" });
+    });
+}

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

@@ -0,0 +1,19 @@
+export declare class v2_AccountCategory {
+    private readonly apiKey;
+    constructor(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
+     */
+    get(name: string, tag: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<import("./getAccount").v2_getAccount_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+    /**
+     * @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
+     */
+    getByPuuid(puuid: string, force?: boolean): Promise<import("../../types/response.type").DefaultApiResponse<import("./getAccountByPuuid").v2_getAccountByPuuid_ResponseData> | import("../../types/response.type").DefaultErrorsResponse>;
+}

package/dist/account/v2/index.js

@@ -0,0 +1,43 @@
+"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_AccountCategory = void 0;
+const getAccount_1 = require("./getAccount");
+const getAccountByPuuid_1 = require("./getAccountByPuuid");
+class v2_AccountCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * @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
+     */
+    get(name, tag, force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getAccount_1.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
+     */
+    getByPuuid(puuid, force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getAccountByPuuid_1.v2_getAccountByPuuid)(this.apiKey, puuid, force);
+        });
+    }
+}
+exports.v2_AccountCategory = v2_AccountCategory;

package/dist/constants/api.const.d.ts

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

package/dist/constants/api.const.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiURL = void 0;
+exports.apiURL = "https://api.henrikdev.xyz";

package/dist/crosshair/index.d.ts

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

package/dist/crosshair/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrosshairCategory = void 0;
+const v1_1 = require("./v1");
+class CrosshairCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.v1 = new v1_1.v1_CrosshairCategory(this.apiKey);
+    }
+}
+exports.CrosshairCategory = CrosshairCategory;

package/dist/crosshair/v1/generateCrosshairImage.d.ts

@@ -0,0 +1 @@
+export declare function v1_generateCrosshairImage(apiKey: string, id?: string): Promise<import("../../types/response.type").DefaultApiResponse<unknown> | import("../../types/response.type").DefaultErrorsResponse>;

package/dist/crosshair/v1/generateCrosshairImage.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.v1_generateCrosshairImage = v1_generateCrosshairImage;
+const request_handler_1 = require("../../lib/request-handler");
+function v1_generateCrosshairImage(apiKey, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, "/valorant/v1/crosshair/generate", { id }, { method: "GET" });
+    });
+}

package/dist/crosshair/v1/index.d.ts

@@ -0,0 +1,10 @@
+export declare class v1_CrosshairCategory {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/generate-crosshair-image-v1
+     * @param id Crosshair code
+     * @returns Crosshair image generated successfully
+     */
+    generateImage(id?: string): Promise<import("../../types/response.type").DefaultApiResponse<unknown> | import("../../types/response.type").DefaultErrorsResponse>;
+}

package/dist/crosshair/v1/index.js

@@ -0,0 +1,29 @@
+"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.v1_CrosshairCategory = void 0;
+const generateCrosshairImage_1 = require("./generateCrosshairImage");
+class v1_CrosshairCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/generate-crosshair-image-v1
+     * @param id Crosshair code
+     * @returns Crosshair image generated successfully
+     */
+    generateImage(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, generateCrosshairImage_1.v1_generateCrosshairImage)(this.apiKey, id);
+        });
+    }
+}
+exports.v1_CrosshairCategory = v1_CrosshairCategory;

package/dist/esports/index.d.ts

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

package/dist/esports/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EsportsCategory = void 0;
+const v1_1 = require("./v1");
+class EsportsCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.v1 = new v1_1.v1_EsportsCategory(this.apiKey);
+    }
+}
+exports.EsportsCategory = EsportsCategory;

package/dist/esports/v1/getEsportsSchedule.d.ts

@@ -0,0 +1,35 @@
+export declare function v1_getEsportsSchedule(apiKey: string, region?: string, league?: string): Promise<import("../../types/response.type").DefaultApiResponse<v1_getEsportsSchedule_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+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/dist/esports/v1/getEsportsSchedule.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.v1_getEsportsSchedule = v1_getEsportsSchedule;
+const request_handler_1 = require("../../lib/request-handler");
+function v1_getEsportsSchedule(apiKey, region, league) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, request_handler_1.doApiRequest)(apiKey, "/valorant/v1/esports/schedule", { region, league }, { method: "GET" });
+    });
+}

package/dist/esports/v1/index.d.ts

@@ -0,0 +1,11 @@
+export declare class v1_EsportsCategory {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-esports-schedule-v1
+     * @param region
+     * @param league
+     * @returns Esports schedule retrieved successfully
+     */
+    getSchedule(region?: string, league?: string): Promise<import("../../types/response.type").DefaultApiResponse<import("./getEsportsSchedule").v1_getEsportsSchedule_ResponseData[]> | import("../../types/response.type").DefaultErrorsResponse>;
+}

package/dist/esports/v1/index.js

@@ -0,0 +1,30 @@
+"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.v1_EsportsCategory = void 0;
+const getEsportsSchedule_1 = require("./getEsportsSchedule");
+class v1_EsportsCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * @link https://docs.henrikdev.xyz/api-reference/valorant/get-esports-schedule-v1
+     * @param region
+     * @param league
+     * @returns Esports schedule retrieved successfully
+     */
+    getSchedule(region, league) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, getEsportsSchedule_1.v1_getEsportsSchedule)(this.apiKey, region, league);
+        });
+    }
+}
+exports.v1_EsportsCategory = v1_EsportsCategory;

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+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 declare class UnofficialValorantAPI {
+    private readonly apiKey;
+    constructor(apiKey: string);
+    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/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnofficialValorantAPI = void 0;
+const account_1 = require("./account");
+const crosshair_1 = require("./crosshair");
+const esports_1 = require("./esports");
+const leaderboard_1 = require("./leaderboard");
+const match_details_1 = require("./match-details");
+const matches_1 = require("./matches");
+const misc_1 = require("./misc");
+const mmr_1 = require("./mmr");
+const mmr_history_1 = require("./mmr-history");
+const premier_1 = require("./premier");
+const premier_history_1 = require("./premier-history");
+const premier_leaderboard_1 = require("./premier-leaderboard");
+const premium_1 = require("./premium");
+const store_1 = require("./store");
+const stored_matches_1 = require("./stored-matches");
+const stored_mmr_history_1 = require("./stored-mmr-history");
+const vlr_1 = require("./vlr");
+class UnofficialValorantAPI {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.Account = new account_1.AccountCategory(this.apiKey);
+        this.Crosshair = new crosshair_1.CrosshairCategory(this.apiKey);
+        this.Esports = new esports_1.EsportsCategory(this.apiKey);
+        this.Leaderboard = new leaderboard_1.LeaderboardCategory(this.apiKey);
+        this.Match_Details = new match_details_1.MatchDetailsCategory(this.apiKey);
+        this.Matches = new matches_1.MatchesCategory(this.apiKey);
+        this.Misc = new misc_1.MiscCategory(this.apiKey);
+        this.MMR = new mmr_1.MMRCategory(this.apiKey);
+        this.MMR_History = new mmr_history_1.MMRHistoryCategory(this.apiKey);
+        this.Premier = new premier_1.PremierCategory(this.apiKey);
+        this.Premier_History = new premier_history_1.PremierHistoryCategory(this.apiKey);
+        this.Premier_Leaderboard = new premier_leaderboard_1.PremierLeaderboardCategory(this.apiKey);
+        this.Premium = new premium_1.PremiumCategory(this.apiKey);
+        this.Store = new store_1.StoreCategory(this.apiKey);
+        this.Stored_Matches = new stored_matches_1.StoredMatchesCategory(this.apiKey);
+        this.Stored_MMR_History = new stored_mmr_history_1.StoredMMRHistoryCategory(this.apiKey);
+        this.Vlr = new vlr_1.VlrCategory(this.apiKey);
+    }
+}
+exports.UnofficialValorantAPI = UnofficialValorantAPI;

package/dist/leaderboard/index.d.ts

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

package/dist/leaderboard/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaderboardCategory = void 0;
+const v1_1 = require("./v1");
+const v2_1 = require("./v2");
+const v3_1 = require("./v3");
+class LeaderboardCategory {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.v1 = new v1_1.v1_LeaderboardCategory(this.apiKey);
+        this.v2 = new v2_1.v2_LeaderboardCategory(this.apiKey);
+        this.v3 = new v3_1.v3_LeaderboardCategory(this.apiKey);
+    }
+}
+exports.LeaderboardCategory = LeaderboardCategory;

package/dist/leaderboard/v1/getLeaderboard.d.ts

@@ -0,0 +1,3 @@
+export declare function v1_getLeaderboard(apiKey: string, affinity: string, season?: string, name?: string, tag?: string): Promise<import("../../types/response.type").DefaultApiResponse<unknown> | import("../../types/response.type").DefaultErrorsResponse>;
+export interface v1_getLeaderboard_ResponseData {
+}