@valpro-labs/valorant-api 1.0.0

package/dist/endpoints/CompetitiveTiersEndpoints.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const TierSchema: z.ZodObject<{
+    tier: z.ZodNumber;
+    tierName: z.ZodString;
+    division: z.ZodString;
+    divisionName: z.ZodString;
+    color: z.ZodString;
+    backgroundColor: z.ZodString;
+    smallIcon: z.ZodNullable<z.ZodString>;
+    largeIcon: z.ZodNullable<z.ZodString>;
+    rankTriangleDownIcon: z.ZodNullable<z.ZodString>;
+    rankTriangleUpIcon: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const CompetitiveTierSetSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    assetObjectName: z.ZodString;
+    tiers: z.ZodArray<z.ZodObject<{
+        tier: z.ZodNumber;
+        tierName: z.ZodString;
+        division: z.ZodString;
+        divisionName: z.ZodString;
+        color: z.ZodString;
+        backgroundColor: z.ZodString;
+        smallIcon: z.ZodNullable<z.ZodString>;
+        largeIcon: z.ZodNullable<z.ZodString>;
+        rankTriangleDownIcon: z.ZodNullable<z.ZodString>;
+        rankTriangleUpIcon: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export declare const CompetitiveTiersSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    assetObjectName: z.ZodString;
+    tiers: z.ZodArray<z.ZodObject<{
+        tier: z.ZodNumber;
+        tierName: z.ZodString;
+        division: z.ZodString;
+        divisionName: z.ZodString;
+        color: z.ZodString;
+        backgroundColor: z.ZodString;
+        smallIcon: z.ZodNullable<z.ZodString>;
+        largeIcon: z.ZodNullable<z.ZodString>;
+        rankTriangleDownIcon: z.ZodNullable<z.ZodString>;
+        rankTriangleUpIcon: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type TierResponse = z.infer<typeof TierSchema>;
+export type CompetitiveTierSetResponse = z.infer<typeof CompetitiveTierSetSchema>;
+export type CompetitiveTiersResponse = z.infer<typeof CompetitiveTiersSchema>;
+declare class CompetitiveTiersEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    getCompetitiveTiersV1(): Promise<CompetitiveTiersResponse>;
+    getCompetitiveTiersByUuidV1(uuid: string): Promise<CompetitiveTierSetResponse>;
+}
+export { CompetitiveTiersEndpoints };

package/dist/endpoints/CompetitiveTiersEndpoints.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompetitiveTiersEndpoints = exports.CompetitiveTiersSchema = exports.CompetitiveTierSetSchema = exports.TierSchema = void 0;
+const zod_1 = require("zod");
+const BaseEndpoint_1 = require("./BaseEndpoint");
+exports.TierSchema = zod_1.z.object({
+    tier: zod_1.z.number().int(),
+    tierName: zod_1.z.string(),
+    division: zod_1.z.string(),
+    divisionName: zod_1.z.string(),
+    color: zod_1.z.string(),
+    backgroundColor: zod_1.z.string(),
+    smallIcon: zod_1.z.string().nullable(),
+    largeIcon: zod_1.z.string().nullable(),
+    rankTriangleDownIcon: zod_1.z.string().nullable(),
+    rankTriangleUpIcon: zod_1.z.string().nullable(),
+});
+exports.CompetitiveTierSetSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    assetObjectName: zod_1.z.string(),
+    tiers: zod_1.z.array(exports.TierSchema),
+    assetPath: zod_1.z.string(),
+});
+exports.CompetitiveTiersSchema = zod_1.z.array(exports.CompetitiveTierSetSchema);
+class CompetitiveTiersEndpoints extends BaseEndpoint_1.BaseEndpoint {
+    constructor(config) {
+        super(config);
+    }
+    async getCompetitiveTiersV1() {
+        return this.requestValorantApi('v1/competitivetiers');
+    }
+    async getCompetitiveTiersByUuidV1(uuid) {
+        return this.requestValorantApi(`v1/competitivetiers/${uuid}`);
+    }
+}
+exports.CompetitiveTiersEndpoints = CompetitiveTiersEndpoints;

package/dist/endpoints/ContentTierEndpoints.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const ContentTierSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    devName: z.ZodString;
+    rank: z.ZodNumber;
+    juiceValue: z.ZodNumber;
+    juiceCost: z.ZodNumber;
+    highlightColor: z.ZodString;
+    displayIcon: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export declare const ContentTiersSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    devName: z.ZodString;
+    rank: z.ZodNumber;
+    juiceValue: z.ZodNumber;
+    juiceCost: z.ZodNumber;
+    highlightColor: z.ZodString;
+    displayIcon: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type ContentTierResponse = z.infer<typeof ContentTierSchema>;
+export type ContentTiersResponse = z.infer<typeof ContentTiersSchema>;
+declare class ContentTierEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    getContentTiersV1(): Promise<ContentTiersResponse>;
+    getContentTierByUuidV1(uuid: string): Promise<ContentTierResponse>;
+}
+export { ContentTierEndpoints };

package/dist/endpoints/ContentTierEndpoints.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentTierEndpoints = exports.ContentTiersSchema = exports.ContentTierSchema = void 0;
+const zod_1 = require("zod");
+const BaseEndpoint_1 = require("./BaseEndpoint");
+exports.ContentTierSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    displayName: zod_1.z.string(),
+    devName: zod_1.z.string(),
+    rank: zod_1.z.number().int(),
+    juiceValue: zod_1.z.number().int(),
+    juiceCost: zod_1.z.number().int(),
+    highlightColor: zod_1.z.string(),
+    displayIcon: zod_1.z.string().url(),
+    assetPath: zod_1.z.string(),
+});
+exports.ContentTiersSchema = zod_1.z.array(exports.ContentTierSchema);
+class ContentTierEndpoints extends BaseEndpoint_1.BaseEndpoint {
+    constructor(config) {
+        super(config);
+    }
+    async getContentTiersV1() {
+        return this.requestValorantApi('v1/contenttiers');
+    }
+    async getContentTierByUuidV1(uuid) {
+        return this.requestValorantApi(`v1/contenttiers/${uuid}`);
+    }
+}
+exports.ContentTierEndpoints = ContentTierEndpoints;

package/dist/endpoints/ContractsEndpoints.d.ts

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const RewardSchema: z.ZodObject<{
+    type: z.ZodString;
+    uuid: z.ZodString;
+    amount: z.ZodNumber;
+    isHighlighted: z.ZodBoolean;
+}, z.core.$strip>;
+export type RewardResponse = z.infer<typeof RewardSchema>;
+export declare const ContractLevelSchema: z.ZodObject<{
+    reward: z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        amount: z.ZodNumber;
+        isHighlighted: z.ZodBoolean;
+    }, z.core.$strip>;
+    xp: z.ZodNumber;
+    vpCost: z.ZodNumber;
+    isPurchasableWithVP: z.ZodBoolean;
+    doughCost: z.ZodNumber;
+    isPurchasableWithDough: z.ZodBoolean;
+}, z.core.$strip>;
+export type ContractLevelResponse = z.infer<typeof ContractLevelSchema>;
+export declare const ChapterSchema: z.ZodObject<{
+    isEpilogue: z.ZodBoolean;
+    levels: z.ZodArray<z.ZodObject<{
+        reward: z.ZodObject<{
+            type: z.ZodString;
+            uuid: z.ZodString;
+            amount: z.ZodNumber;
+            isHighlighted: z.ZodBoolean;
+        }, z.core.$strip>;
+        xp: z.ZodNumber;
+        vpCost: z.ZodNumber;
+        isPurchasableWithVP: z.ZodBoolean;
+        doughCost: z.ZodNumber;
+        isPurchasableWithDough: z.ZodBoolean;
+    }, z.core.$strip>>;
+    freeRewards: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        uuid: z.ZodString;
+        amount: z.ZodNumber;
+        isHighlighted: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ChapterResponse = z.infer<typeof ChapterSchema>;
+export declare const ContractContentSchema: z.ZodObject<{
+    relationType: z.ZodNullable<z.ZodString>;
+    relationUuid: z.ZodNullable<z.ZodString>;
+    chapters: z.ZodArray<z.ZodObject<{
+        isEpilogue: z.ZodBoolean;
+        levels: z.ZodArray<z.ZodObject<{
+            reward: z.ZodObject<{
+                type: z.ZodString;
+                uuid: z.ZodString;
+                amount: z.ZodNumber;
+                isHighlighted: z.ZodBoolean;
+            }, z.core.$strip>;
+            xp: z.ZodNumber;
+            vpCost: z.ZodNumber;
+            isPurchasableWithVP: z.ZodBoolean;
+            doughCost: z.ZodNumber;
+            isPurchasableWithDough: z.ZodBoolean;
+        }, z.core.$strip>>;
+        freeRewards: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            uuid: z.ZodString;
+            amount: z.ZodNumber;
+            isHighlighted: z.ZodBoolean;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    premiumRewardScheduleUuid: z.ZodNullable<z.ZodString>;
+    premiumVPCost: z.ZodNumber;
+}, z.core.$strip>;
+export type ContractContentResponse = z.infer<typeof ContractContentSchema>;
+export declare const ContractSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    displayIcon: z.ZodNullable<z.ZodString>;
+    shipIt: z.ZodBoolean;
+    useLevelVPCostOverride: z.ZodBoolean;
+    levelVPCostOverride: z.ZodNumber;
+    freeRewardScheduleUuid: z.ZodNullable<z.ZodString>;
+    content: z.ZodObject<{
+        relationType: z.ZodNullable<z.ZodString>;
+        relationUuid: z.ZodNullable<z.ZodString>;
+        chapters: z.ZodArray<z.ZodObject<{
+            isEpilogue: z.ZodBoolean;
+            levels: z.ZodArray<z.ZodObject<{
+                reward: z.ZodObject<{
+                    type: z.ZodString;
+                    uuid: z.ZodString;
+                    amount: z.ZodNumber;
+                    isHighlighted: z.ZodBoolean;
+                }, z.core.$strip>;
+                xp: z.ZodNumber;
+                vpCost: z.ZodNumber;
+                isPurchasableWithVP: z.ZodBoolean;
+                doughCost: z.ZodNumber;
+                isPurchasableWithDough: z.ZodBoolean;
+            }, z.core.$strip>>;
+            freeRewards: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                uuid: z.ZodString;
+                amount: z.ZodNumber;
+                isHighlighted: z.ZodBoolean;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        premiumRewardScheduleUuid: z.ZodNullable<z.ZodString>;
+        premiumVPCost: z.ZodNumber;
+    }, z.core.$strip>;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export type ContractResponse = z.infer<typeof ContractSchema>;
+export declare const ContractsSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    displayIcon: z.ZodNullable<z.ZodString>;
+    shipIt: z.ZodBoolean;
+    useLevelVPCostOverride: z.ZodBoolean;
+    levelVPCostOverride: z.ZodNumber;
+    freeRewardScheduleUuid: z.ZodNullable<z.ZodString>;
+    content: z.ZodObject<{
+        relationType: z.ZodNullable<z.ZodString>;
+        relationUuid: z.ZodNullable<z.ZodString>;
+        chapters: z.ZodArray<z.ZodObject<{
+            isEpilogue: z.ZodBoolean;
+            levels: z.ZodArray<z.ZodObject<{
+                reward: z.ZodObject<{
+                    type: z.ZodString;
+                    uuid: z.ZodString;
+                    amount: z.ZodNumber;
+                    isHighlighted: z.ZodBoolean;
+                }, z.core.$strip>;
+                xp: z.ZodNumber;
+                vpCost: z.ZodNumber;
+                isPurchasableWithVP: z.ZodBoolean;
+                doughCost: z.ZodNumber;
+                isPurchasableWithDough: z.ZodBoolean;
+            }, z.core.$strip>>;
+            freeRewards: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                uuid: z.ZodString;
+                amount: z.ZodNumber;
+                isHighlighted: z.ZodBoolean;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        premiumRewardScheduleUuid: z.ZodNullable<z.ZodString>;
+        premiumVPCost: z.ZodNumber;
+    }, z.core.$strip>;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type ContractsResponse = z.infer<typeof ContractsSchema>;
+declare class ContractsEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    /**
+     * Get all contracts
+     * @returns Promise<ContractsResponse>
+     */
+    getContractsV1(): Promise<ContractsResponse>;
+    /**
+     * Get contract by UUID
+     * @param uuid Contract UUID
+     * @returns Promise<ContractResponse>
+     */
+    getContractByUuidV1(uuid: string): Promise<ContractResponse>;
+}
+export { ContractsEndpoints };

package/dist/endpoints/ContractsEndpoints.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractsEndpoints = exports.ContractsSchema = exports.ContractSchema = exports.ContractContentSchema = exports.ChapterSchema = exports.ContractLevelSchema = exports.RewardSchema = void 0;
+const zod_1 = require("zod");
+const BaseEndpoint_1 = require("./BaseEndpoint");
+exports.RewardSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    uuid: zod_1.z.string().uuid(),
+    amount: zod_1.z.number().int(),
+    isHighlighted: zod_1.z.boolean(),
+});
+exports.ContractLevelSchema = zod_1.z.object({
+    reward: exports.RewardSchema,
+    xp: zod_1.z.number().int(),
+    vpCost: zod_1.z.number().int(),
+    isPurchasableWithVP: zod_1.z.boolean(),
+    doughCost: zod_1.z.number().int(),
+    isPurchasableWithDough: zod_1.z.boolean(),
+});
+exports.ChapterSchema = zod_1.z.object({
+    isEpilogue: zod_1.z.boolean(),
+    levels: zod_1.z.array(exports.ContractLevelSchema),
+    freeRewards: zod_1.z.array(exports.RewardSchema).nullable(),
+});
+exports.ContractContentSchema = zod_1.z.object({
+    relationType: zod_1.z.string().nullable(),
+    relationUuid: zod_1.z.string().uuid().nullable(),
+    chapters: zod_1.z.array(exports.ChapterSchema),
+    premiumRewardScheduleUuid: zod_1.z.string().uuid().nullable(),
+    premiumVPCost: zod_1.z.number().int(),
+});
+exports.ContractSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    displayName: zod_1.z.string(),
+    displayIcon: zod_1.z.string().nullable(),
+    shipIt: zod_1.z.boolean(),
+    useLevelVPCostOverride: zod_1.z.boolean(),
+    levelVPCostOverride: zod_1.z.number().int(),
+    freeRewardScheduleUuid: zod_1.z.string().uuid().nullable(),
+    content: exports.ContractContentSchema,
+    assetPath: zod_1.z.string(),
+});
+exports.ContractsSchema = zod_1.z.array(exports.ContractSchema);
+// Types already defined above
+class ContractsEndpoints extends BaseEndpoint_1.BaseEndpoint {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Get all contracts
+     * @returns Promise<ContractsResponse>
+     */
+    async getContractsV1() {
+        return this.requestValorantApi('v1/contracts');
+    }
+    /**
+     * Get contract by UUID
+     * @param uuid Contract UUID
+     * @returns Promise<ContractResponse>
+     */
+    async getContractByUuidV1(uuid) {
+        return this.requestValorantApi(`v1/contracts/${uuid}`);
+    }
+}
+exports.ContractsEndpoints = ContractsEndpoints;

package/dist/endpoints/CurrenciesEndpoints.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const CurrencySchema: z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    displayNameSingular: z.ZodString;
+    displayIcon: z.ZodString;
+    largeIcon: z.ZodString;
+    rewardPreviewIcon: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export declare const CurrenciesSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    displayNameSingular: z.ZodString;
+    displayIcon: z.ZodString;
+    largeIcon: z.ZodString;
+    rewardPreviewIcon: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type CurrencyResponse = z.infer<typeof CurrencySchema>;
+export type CurrenciesResponse = z.infer<typeof CurrenciesSchema>;
+declare class CurrenciesEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    getCurrenciesV1(): Promise<CurrenciesResponse>;
+    getCurrencyByUuidV1(uuid: string): Promise<CurrencyResponse>;
+}
+export { CurrenciesEndpoints };

package/dist/endpoints/CurrenciesEndpoints.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrenciesEndpoints = exports.CurrenciesSchema = exports.CurrencySchema = void 0;
+const zod_1 = require("zod");
+const BaseEndpoint_1 = require("./BaseEndpoint");
+exports.CurrencySchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    displayName: zod_1.z.string(),
+    displayNameSingular: zod_1.z.string(),
+    displayIcon: zod_1.z.string().url(),
+    largeIcon: zod_1.z.string().url(),
+    rewardPreviewIcon: zod_1.z.string().url(),
+    assetPath: zod_1.z.string(),
+});
+exports.CurrenciesSchema = zod_1.z.array(exports.CurrencySchema);
+class CurrenciesEndpoints extends BaseEndpoint_1.BaseEndpoint {
+    constructor(config) {
+        super(config);
+    }
+    async getCurrenciesV1() {
+        return this.requestValorantApi('v1/currencies');
+    }
+    async getCurrencyByUuidV1(uuid) {
+        return this.requestValorantApi(`v1/currencies/${uuid}`);
+    }
+}
+exports.CurrenciesEndpoints = CurrenciesEndpoints;

package/dist/endpoints/EventsEndpoints.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const EventSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    shortDisplayName: z.ZodString;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export declare const EventsSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    shortDisplayName: z.ZodString;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type EventResponse = z.infer<typeof EventSchema>;
+export type EventsResponse = z.infer<typeof EventsSchema>;
+declare class EventsEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    /**
+     * Get all events
+     * @returns Promise<EventsResponse>
+     */
+    getEventsV1(): Promise<EventsResponse>;
+    /**
+     * Get event by UUID
+     * @param uuid Event UUID
+     * @returns Promise<EventResponse>
+     */
+    getEventByUuidV1(uuid: string): Promise<EventResponse>;
+}
+export { EventsEndpoints };

package/dist/endpoints/EventsEndpoints.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsEndpoints = exports.EventsSchema = exports.EventSchema = void 0;
+const zod_1 = require("zod");
+const BaseEndpoint_1 = require("./BaseEndpoint");
+exports.EventSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    displayName: zod_1.z.string(),
+    shortDisplayName: zod_1.z.string(),
+    startTime: zod_1.z.string(),
+    endTime: zod_1.z.string(),
+    assetPath: zod_1.z.string(),
+});
+exports.EventsSchema = zod_1.z.array(exports.EventSchema);
+class EventsEndpoints extends BaseEndpoint_1.BaseEndpoint {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Get all events
+     * @returns Promise<EventsResponse>
+     */
+    async getEventsV1() {
+        return this.requestValorantApi('v1/events');
+    }
+    /**
+     * Get event by UUID
+     * @param uuid Event UUID
+     * @returns Promise<EventResponse>
+     */
+    async getEventByUuidV1(uuid) {
+        return this.requestValorantApi(`v1/events/${uuid}`);
+    }
+}
+exports.EventsEndpoints = EventsEndpoints;

package/dist/endpoints/FlexEndpoints.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const FlexSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    displayNameAllCaps: z.ZodString;
+    displayIcon: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export declare const FlexsSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    displayNameAllCaps: z.ZodString;
+    displayIcon: z.ZodString;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type FlexResponse = z.infer<typeof FlexSchema>;
+export type FlexsResponse = z.infer<typeof FlexsSchema>;
+declare class FlexEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    getFlexV1(): Promise<FlexsResponse>;
+    getFlexByUuidV1(uuid: string): Promise<FlexResponse>;
+}
+export { FlexEndpoints };

package/dist/endpoints/FlexEndpoints.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexEndpoints = exports.FlexsSchema = exports.FlexSchema = void 0;
+const zod_1 = require("zod");
+const BaseEndpoint_1 = require("./BaseEndpoint");
+const SharedSchemas_1 = require("../schemas/SharedSchemas");
+exports.FlexSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    displayName: SharedSchemas_1.LocalizedStringSchema,
+    displayNameAllCaps: SharedSchemas_1.LocalizedStringSchema,
+    displayIcon: zod_1.z.string(),
+    assetPath: zod_1.z.string(),
+});
+exports.FlexsSchema = zod_1.z.array(exports.FlexSchema);
+class FlexEndpoints extends BaseEndpoint_1.BaseEndpoint {
+    constructor(config) {
+        super(config);
+    }
+    async getFlexV1() {
+        return this.requestValorantApi('v1/flex');
+    }
+    async getFlexByUuidV1(uuid) {
+        return this.requestValorantApi(`v1/flex/${uuid}`);
+    }
+}
+exports.FlexEndpoints = FlexEndpoints;

package/dist/endpoints/GameModesEndpoints.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { BaseEndpoint, ValorantApiConfig } from './BaseEndpoint';
+export declare const GameFeatureOverrideSchema: z.ZodObject<{
+    featureName: z.ZodString;
+    state: z.ZodBoolean;
+}, z.core.$strip>;
+export type GameFeatureOverrideResponse = z.infer<typeof GameFeatureOverrideSchema>;
+export declare const GameRuleBoolOverrideSchema: z.ZodObject<{
+    ruleName: z.ZodString;
+    state: z.ZodBoolean;
+}, z.core.$strip>;
+export type GameRuleBoolOverrideResponse = z.infer<typeof GameRuleBoolOverrideSchema>;
+export declare const GameModeSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    duration: z.ZodNullable<z.ZodString>;
+    economyType: z.ZodNullable<z.ZodString>;
+    allowsMatchTimeouts: z.ZodBoolean;
+    allowsCustomGameReplays: z.ZodBoolean;
+    isTeamVoiceAllowed: z.ZodBoolean;
+    isMinimapHidden: z.ZodBoolean;
+    orbCount: z.ZodNumber;
+    roundsPerHalf: z.ZodNumber;
+    teamRoles: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    gameFeatureOverrides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        featureName: z.ZodString;
+        state: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+    gameRuleBoolOverrides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        ruleName: z.ZodString;
+        state: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+    displayIcon: z.ZodNullable<z.ZodString>;
+    listViewIconTall: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assetPath: z.ZodString;
+}, z.core.$strip>;
+export declare const GameModesSchema: z.ZodArray<z.ZodObject<{
+    uuid: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    duration: z.ZodNullable<z.ZodString>;
+    economyType: z.ZodNullable<z.ZodString>;
+    allowsMatchTimeouts: z.ZodBoolean;
+    allowsCustomGameReplays: z.ZodBoolean;
+    isTeamVoiceAllowed: z.ZodBoolean;
+    isMinimapHidden: z.ZodBoolean;
+    orbCount: z.ZodNumber;
+    roundsPerHalf: z.ZodNumber;
+    teamRoles: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    gameFeatureOverrides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        featureName: z.ZodString;
+        state: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+    gameRuleBoolOverrides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        ruleName: z.ZodString;
+        state: z.ZodBoolean;
+    }, z.core.$strip>>>>;
+    displayIcon: z.ZodNullable<z.ZodString>;
+    listViewIconTall: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assetPath: z.ZodString;
+}, z.core.$strip>>;
+export type GameModeResponse = z.infer<typeof GameModeSchema>;
+export type GameModesResponse = z.infer<typeof GameModesSchema>;
+declare class GameModesEndpoints extends BaseEndpoint {
+    constructor(config?: ValorantApiConfig);
+    getGameModesV1(): Promise<GameModesResponse>;
+    getGameModeByUuidV1(uuid: string): Promise<GameModeResponse>;
+}
+export { GameModesEndpoints };