@notidotbot/noti-api-client 1.4.16 → 1.4.18

package/dist/classes/client.d.ts

@@ -40,13 +40,13 @@ export declare class APIClient {
         content: string;
         thumbnail: string | null;
         authorIcon: string;
+        tags: string[];
         clientId: string;
         identifier: string;
         isPinned: boolean;
         views: number | null;
         reactions: string[];
         reactionsCount: number | null;
-        tags: string[];
         authorName: string;
         createdAt: Date;
         lastEdited: Date;

package/dist/classes/dropsGames.d.ts

@@ -31,6 +31,14 @@ export type DropsGamesReturnTypes = {
 };
 export type DropsGameData = {
     id: string;
+    /**
+     * Every platform-specific DropGame dbId backing this merged entry. The same game can
+     * exist on multiple platforms (e.g. Kick "rust" and Twitch "263490") as separate rows,
+     * each with its own id. A guild stores only ONE of these on its filter, so consumers
+     * must check a configured id against ALL `ids` — checking only `id` makes a configured
+     * game appear disabled when the merge surfaces a different platform's id.
+     */
+    ids?: string[];
     gameId: string;
     platform?: string;
     platforms?: string[];

package/dist/classes/games.d.ts

@@ -0,0 +1,363 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses, WebResponse } from '../types';
+export type GameStore = 'steam' | 'epic' | 'gog' | 'prime';
+export type GameKind = 'free_game' | 'free_dlc_or_loot' | 'discount' | 'upcoming_free';
+export type GameDiscountTier = '100' | '90_plus' | '75_plus' | '50_plus' | '33_plus' | 'under_33';
+export type GameDelivery = 'instant' | 'daily' | 'weekly';
+export type GameFlag = 'freeWeekend' | 'allTimeLow' | 'featured' | 'aaa' | 'earlyAccess';
+export type GameSourceId = 'epic_free' | 'cheapshark' | 'steam_featured' | 'gamerpower' | 'watchlist' | 'steam_weekend';
+export interface DealPrice {
+    currency: 'USD';
+    originalCents: number | null;
+    finalCents: number | null;
+    discountPercent: number;
+}
+export interface DealArtwork {
+    wide: string | null;
+    tall: string | null;
+    thumb: string | null;
+    header: string | null;
+}
+export interface DealRatings {
+    steamRatingPercent: number | null;
+    steamRatingCount: number | null;
+    steamRatingText: string | null;
+    metacritic: number | null;
+    dealRating: number | null;
+}
+export interface DealFlags {
+    aaa: boolean;
+    featured: boolean;
+    earlyAccess: boolean;
+    freeWeekend: boolean;
+    allTimeLow: boolean;
+}
+/** One catalog item — the single shape every catalog endpoint + WS event speaks. */
+export interface DealItem {
+    id: string;
+    kind: GameKind;
+    store: GameStore;
+    title: string;
+    description: string | null;
+    isDlcOrAddon: boolean;
+    price: DealPrice;
+    discountTier: GameDiscountTier;
+    worth: string | null;
+    /** canonical store/claim URL — what the user should click */
+    url: string;
+    /** CheapShark redirect URL — use this for deal links when present (terms requirement) */
+    dealUrl: string | null;
+    artwork: DealArtwork;
+    startsAt: string | null;
+    /** claim deadline for free-to-keep items; price-revert for discounts */
+    endsAt: string | null;
+    /** end of a Steam play-for-free window — independent of endsAt */
+    freeWeekendEndsAt: string | null;
+    flags: DealFlags;
+    ratings: DealRatings | null;
+    steamAppId: number | null;
+    cheapsharkGameId: string | null;
+    allTimeLowCents: number | null;
+    /** enrichment — null until metadata lands (show a skeleton, not broken UI) */
+    developers: string[] | null;
+    publishers: string[] | null;
+    genres: string[] | null;
+    tags: string[] | null;
+    enrichedAt: string | null;
+    watched: boolean;
+    sources: GameSourceId[];
+    sourceIds: Partial<Record<GameSourceId, string>>;
+    firstSeenAt: string;
+    updatedAt: string;
+    lastSeenAt: string;
+}
+export interface ChangelogEntry {
+    id: string;
+    appid: number;
+    title: string;
+    gameTitle: string | null;
+    kind: 'patch' | 'announcement';
+    url: string;
+    author: string | null;
+    /** Discord-ready markdown, ≤1500 chars */
+    contentsPreview: string;
+    publishedAt: string;
+    feedLabel: string;
+}
+export interface DealsCatalogResponse {
+    items: DealItem[];
+    nextCursor: string | null;
+    total: number;
+    asOf: string;
+}
+export interface FreeCatalogResponse {
+    items: DealItem[];
+    total: number;
+    asOf: string;
+}
+export interface ChangelogsResponse {
+    items: ChangelogEntry[];
+    total: number;
+    asOf: string;
+}
+export interface ProviderCapabilities {
+    giveaways: boolean;
+    discounts: boolean;
+    upcomingFree: boolean;
+    freeWeekends: boolean;
+    allTimeLows: boolean;
+}
+export interface ProviderCounts {
+    items: number;
+    freeNow: number;
+    discounts: number;
+    upcomingFree: number;
+    freeWeekends: number;
+    allTimeLows: number;
+}
+export interface Provider {
+    id: GameStore;
+    label: string;
+    capabilities: ProviderCapabilities;
+    counts: ProviderCounts;
+}
+export interface ProvidersResponse {
+    providers: Provider[];
+    asOf: string;
+}
+export interface TaxonomyTerm {
+    name: string;
+    count: number;
+}
+export interface TaxonomyResponse {
+    genres: TaxonomyTerm[];
+    tags: TaxonomyTerm[];
+    developers: TaxonomyTerm[];
+    publishers: TaxonomyTerm[];
+}
+export interface GameCategoryRoute {
+    dbId?: string;
+    kinds: GameKind[];
+    stores: GameStore[];
+    flags: GameFlag[];
+    genres: string[];
+    tags: string[];
+    minDiscountPercent: number | null;
+    channelId: string | null;
+    pingRoleId: string | null;
+    webhookEnabled?: boolean | null;
+    webhookUsername?: string | null;
+    webhookAvatarUrl?: string | null;
+    priority: number;
+}
+export interface TrackedGame {
+    dbId?: string;
+    steamAppId: number | null;
+    title: string | null;
+    itemId?: string | null;
+    channelId?: string | null;
+    pingRoleId?: string | null;
+    minDiscountPercent?: number | null;
+    atlOnly?: boolean;
+}
+export interface ChangelogGame {
+    dbId?: string;
+    steamAppId: number;
+    title: string | null;
+}
+export interface GameConfig {
+    guildId?: string;
+    enabled: boolean;
+    notificationChannelId: string | null;
+    pingRoleId: string | null;
+    deliveryMode: GameDelivery;
+    digestHourUTC: number | null;
+    digestWeekday: number | null;
+    freeGamesEnabled: boolean;
+    freeDlcEnabled: boolean;
+    freeGameStores: GameStore[];
+    upcomingFreeEnabled: boolean;
+    freeWeekendEnabled: boolean;
+    discountsEnabled: boolean;
+    discountStores: GameStore[];
+    minDiscountPercent: number | null;
+    maxPriceCents: number | null;
+    genres: string[];
+    tags: string[];
+    studios: string[];
+    allTimeLowEnabled: boolean;
+    allTimeLowMaxPriceCents: number | null;
+    changelogChannelId: string | null;
+    changelogPingRoleId: string | null;
+    categoryRoutes: GameCategoryRoute[];
+    trackedGames: TrackedGame[];
+    changelogGames: ChangelogGame[];
+}
+/** Resolved premium entitlements + limits for the guild (gating is visual, never hidden). */
+export interface GameEntitlements {
+    premium: boolean;
+    categoryRouting: boolean;
+    allTimeLow: boolean;
+    customWebhooks: boolean;
+    changelogs: boolean;
+    trackedGameLimit: number;
+}
+export interface GameConfigResponse {
+    config: GameConfig;
+    entitlements: GameEntitlements;
+}
+export interface GameSourceHealth {
+    lastSuccessAt: string | null;
+    lastError: string | null;
+    consecutiveFailures: number;
+    state: string;
+}
+export interface GameHealthBundle {
+    bot: {
+        enabled: boolean;
+        wsConnected: boolean;
+        dashboards: number;
+        trackedGuilds: number;
+    };
+    gameApi: {
+        status: 'ok' | 'degraded';
+        uptimeSec: number;
+        itemCount: number;
+        seq: number;
+        enrichmentQueue: number;
+        sources: Record<string, GameSourceHealth>;
+    } | null;
+}
+export type GamesWsEvent = {
+    op: 'hello';
+    connected: boolean;
+    wsReady: boolean;
+    serverTime: string;
+} | {
+    op: 'pong';
+    t: number;
+} | {
+    op: 'event';
+    type: GameDealEventType;
+    at: string;
+    item: DealItem;
+} | {
+    op: 'event';
+    type: 'changelog.new';
+    at: string;
+    changelog: ChangelogEntry;
+};
+export type GameDealEventType = 'deal.new' | 'deal.updated' | 'deal.expired' | 'deal.enriched' | 'free.new' | 'free.upcoming' | 'free.expired' | 'free.weekend' | 'deal.lowest';
+export declare class APIGames {
+    private web;
+    constructor(web: WebDataManager);
+    getConfig({ auth, guildId }: GamesFunctionsInput['getConfig']): Promise<WebResponse<GameConfigResponse>>;
+    updateConfig({ auth, guildId, ...body }: GamesFunctionsInput['updateConfig']): Promise<WebResponse<GameConfig>>;
+    updateTrackedGames({ auth, guildId, games }: GamesFunctionsInput['updateTrackedGames']): Promise<WebResponse<{
+        games: TrackedGame[];
+    }>>;
+    updateChangelogGames({ auth, guildId, games }: GamesFunctionsInput['updateChangelogGames']): Promise<WebResponse<{
+        games: ChangelogGame[];
+    }>>;
+    updateCategoryRoutes({ auth, guildId, routes }: GamesFunctionsInput['updateCategoryRoutes']): Promise<WebResponse<{
+        routes: GameCategoryRoute[];
+    }>>;
+    getProviders({ auth, guildId }: GamesFunctionsInput['getProviders']): Promise<WebResponse<ProvidersResponse>>;
+    getTaxonomy({ auth, guildId, store }: GamesFunctionsInput['getTaxonomy']): Promise<WebResponse<TaxonomyResponse>>;
+    getFree({ auth, guildId, store, dlc, playFree }: GamesFunctionsInput['getFree']): Promise<WebResponse<FreeCatalogResponse>>;
+    getUpcoming({ auth, guildId, store }: GamesFunctionsInput['getUpcoming']): Promise<WebResponse<FreeCatalogResponse>>;
+    getDeals({ auth, guildId, ...query }: GamesFunctionsInput['getDeals']): Promise<WebResponse<DealsCatalogResponse>>;
+    getChangelogs({ auth, guildId, appid, kind, limit }: GamesFunctionsInput['getChangelogs']): Promise<WebResponse<ChangelogsResponse>>;
+    getHealth({ auth, guildId }: GamesFunctionsInput['getHealth']): Promise<WebResponse<GameHealthBundle>>;
+}
+export type GameDealsQuery = {
+    kind?: string;
+    store?: string;
+    tier?: string;
+    minDiscount?: number;
+    maxPriceCents?: number;
+    aaa?: boolean;
+    featured?: boolean;
+    freeWeekend?: boolean;
+    atLow?: boolean;
+    genre?: string;
+    tag?: string;
+    developer?: string;
+    publisher?: string;
+    q?: string;
+    endingWithinHours?: number;
+    minRating?: number;
+    sort?: 'updated' | 'discount' | 'ending';
+    limit?: number;
+    cursor?: string;
+};
+export type GamesFunctionsInput = {
+    getConfig: {
+        auth: string;
+        guildId: string;
+    };
+    updateConfig: {
+        auth: string;
+        guildId: string;
+    } & Partial<Omit<GameConfig, 'guildId' | 'categoryRoutes' | 'trackedGames' | 'changelogGames'>>;
+    updateTrackedGames: {
+        auth: string;
+        guildId: string;
+        games: TrackedGame[];
+    };
+    updateChangelogGames: {
+        auth: string;
+        guildId: string;
+        games: ChangelogGame[];
+    };
+    updateCategoryRoutes: {
+        auth: string;
+        guildId: string;
+        routes: GameCategoryRoute[];
+    };
+    getProviders: {
+        auth: string;
+        guildId: string;
+    };
+    getTaxonomy: {
+        auth: string;
+        guildId: string;
+        store?: string;
+    };
+    getFree: {
+        auth: string;
+        guildId: string;
+        store?: string;
+        dlc?: '0' | '1';
+        playFree?: '1';
+    };
+    getUpcoming: {
+        auth: string;
+        guildId: string;
+        store?: string;
+    };
+    getDeals: {
+        auth: string;
+        guildId: string;
+    } & GameDealsQuery;
+    getChangelogs: {
+        auth: string;
+        guildId: string;
+        appid?: number;
+        kind?: 'patch' | 'announcement';
+        limit?: number;
+    };
+    getHealth: {
+        auth: string;
+        guildId: string;
+    };
+};
+export type GamesReturnTypes = {
+    getConfigRaw: Awaited<ReturnType<APIGames['getConfig']>>;
+    getConfigSuccess: CancelOutWebResponses<Awaited<ReturnType<APIGames['getConfig']>>>;
+    getDealsSuccess: CancelOutWebResponses<Awaited<ReturnType<APIGames['getDeals']>>>;
+    getFreeSuccess: CancelOutWebResponses<Awaited<ReturnType<APIGames['getFree']>>>;
+    getProvidersSuccess: CancelOutWebResponses<Awaited<ReturnType<APIGames['getProviders']>>>;
+    getTaxonomySuccess: CancelOutWebResponses<Awaited<ReturnType<APIGames['getTaxonomy']>>>;
+    getHealthSuccess: CancelOutWebResponses<Awaited<ReturnType<APIGames['getHealth']>>>;
+};

package/dist/classes/games.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGames = void 0;
+// ─────────────────────────────────────────────────────────────────────────────
+class APIGames {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // ── Config ──────────────────────────────────────────────────────────────
+    async getConfig({ auth, guildId }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games`) });
+    }
+    async updateConfig({ auth, guildId, ...body }) {
+        return this.web.request({ method: 'PUT', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games`), body });
+    }
+    async updateTrackedGames({ auth, guildId, games }) {
+        return this.web.request({ method: 'PUT', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/tracked`), body: { games } });
+    }
+    async updateChangelogGames({ auth, guildId, games }) {
+        return this.web.request({ method: 'PUT', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/changelogs`), body: { games } });
+    }
+    async updateCategoryRoutes({ auth, guildId, routes }) {
+        return this.web.request({ method: 'PUT', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/routes`), body: { routes } });
+    }
+    // ── Catalog (proxied/cached from gameApi by the bot) ──────────────────────
+    async getProviders({ auth, guildId }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/providers`) });
+    }
+    async getTaxonomy({ auth, guildId, store }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/taxonomy`, { store }) });
+    }
+    async getFree({ auth, guildId, store, dlc, playFree }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/catalog/free`, { store, dlc, playFree }) });
+    }
+    async getUpcoming({ auth, guildId, store }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/catalog/upcoming`, { store }) });
+    }
+    async getDeals({ auth, guildId, ...query }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/catalog/deals`, query) });
+    }
+    async getChangelogs({ auth, guildId, appid, kind, limit }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/catalog/changelogs`, { appid, kind, limit }) });
+    }
+    async getHealth({ auth, guildId }) {
+        return this.web.request({ method: 'GET', auth, endpoint: this.web.qp(`/data/guild/${guildId}/games/health`) });
+    }
+}
+exports.APIGames = APIGames;

package/dist/core/manager.d.ts

@@ -4,6 +4,7 @@ import { APIGuildPlatform } from '../classes/guildPlatform';
 import { APIGuildGiveaway } from '../classes/guildGiveaway';
 import { APIGuildDrops } from '../classes/guildDrops';
 import { APIDropsGames } from '../classes/dropsGames';
+import { APIGames } from '../classes/games';
 import { AxiosResponse } from 'axios';
 import { RequestMethod, WebResponse } from '../types';
 import { APITelemetry } from '../classes/telemetry';
@@ -47,6 +48,7 @@ export declare class WebDataManager {
     readonly guildGiveaway: APIGuildGiveaway;
     readonly guildStarboard: APIGuildStarboard;
     readonly guildPlatformAction: APIPlatformAction;
+    readonly games: APIGames;
     constructor(url: string, options?: {
         log?: boolean;
     } | undefined);

package/dist/core/manager.js

@@ -10,6 +10,7 @@ const guildPlatform_1 = require("../classes/guildPlatform");
 const guildGiveaway_1 = require("../classes/guildGiveaway");
 const guildDrops_1 = require("../classes/guildDrops");
 const dropsGames_1 = require("../classes/dropsGames");
+const games_1 = require("../classes/games");
 const axios_1 = __importDefault(require("axios"));
 const telemetry_1 = require("../classes/telemetry");
 const sessions_1 = require("../classes/sessions");
@@ -51,6 +52,7 @@ class WebDataManager {
     guildGiveaway = new guildGiveaway_1.APIGuildGiveaway(this);
     guildStarboard = new guildStarboard_1.APIGuildStarboard(this);
     guildPlatformAction = new guildPlatformAction_1.APIPlatformAction(this);
+    games = new games_1.APIGames(this);
     constructor(url, options) {
         this.url = url;
         this.options = options;

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export * from './classes/guildPlatform';
 export * from './classes/guildGiveaway';
 export * from './classes/guildStarboard';
 export * from './classes/guildPlatformAction';
+export * from './classes/games';
 export { GuildMessageTypeEnum, StreamerMessageTypeEnum, PlatformEnum, $Enums } from './other/enums';
 export type { Prisma, TSPrisma } from '@prisma/client';
 export type { ClientChangelog, Guild, User, Team, Member, KickStreamer, TwitchStreamer, YoutubeStreamer, TiktokStreamer, RumbleStreamer, GuildGiveaway } from '@prisma/client';

package/dist/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./classes/guildPlatform"), exports);
 __exportStar(require("./classes/guildGiveaway"), exports);
 __exportStar(require("./classes/guildStarboard"), exports);
 __exportStar(require("./classes/guildPlatformAction"), exports);
+__exportStar(require("./classes/games"), exports);
 // Re-export Prisma generated enums (browser-safe)
 var enums_1 = require("./other/enums");
 Object.defineProperty(exports, "GuildMessageTypeEnum", { enumerable: true, get: function () { return enums_1.GuildMessageTypeEnum; } });

package/dist/other/prisma.d.ts

@@ -12,6 +12,7 @@ import { R2StorageZod } from './zod/r2Storage.zod';
 import { MemberZod } from './zod/member.zod';
 import { ClientZod } from './zod/client.zod';
 import { GuildZod } from './zod/guild.zod';
+import { GameConfigZod } from './zod/gameConfig.zod';
 import { DropsZod } from './zod/drops.zod';
 import { UserZod } from './zod/user.zod';
 import { TeamZod } from './zod/team.zod';
@@ -59,6 +60,10 @@ export type GuildDropsWebhookZod = z.infer<typeof DropsZod.GuildDropsWebhookSche
 export type GuildDropsGameZod = z.infer<typeof DropsZod.GuildDropsGameSchema>;
 export type GuildDropsGameWebhookZod = z.infer<typeof DropsZod.GuildDropsGameWebhookSchema>;
 export type SentDropZod = z.infer<typeof DropsZod.SentDropSchema>;
+export type GameConfigZod = z.infer<typeof GameConfigZod.GuildGameConfigSchema>;
+export type GuildGameCategoryRouteZod = z.infer<typeof GameConfigZod.GuildGameCategoryRouteSchema>;
+export type GuildTrackedGameZod = z.infer<typeof GameConfigZod.GuildTrackedGameSchema>;
+export type GuildGameChangelogZod = z.infer<typeof GameConfigZod.GuildGameChangelogSchema>;
 export type AllPlatforms = (typeof PlatformEnum)[keyof typeof PlatformEnum];
 export type AllPlatformsWithVideos = Enums['PlatformsWithVideosEnum'];
 export type PlatformsToLinkType = typeof PlatformsToLink[number];

package/dist/other/zod/gameConfig.zod.d.ts

@@ -0,0 +1,134 @@
+import { PartialZodObject } from './schema.zod';
+import { RemoveProperties } from '../prisma';
+import { TSPrisma } from '@prisma/client';
+import { z } from 'zod';
+export type RT<T extends TSPrisma.AllModelNames> = z.ZodType<RemoveProperties<TSPrisma.TSPrismaModelsFull[T], GameConfigRelations>>;
+export type GameConfigRelations = 'db' | 'gameConfig';
+export declare const GameConfigZod: {
+    readonly GuildGameConfigSchema: z.ZodObject<{
+        guildId: z.ZodString;
+        enabled: z.ZodBoolean;
+        notificationChannelId: z.ZodNullable<z.ZodString>;
+        pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+        deliveryMode: z.ZodEnum<{
+            weekly: "weekly";
+            instant: "instant";
+            daily: "daily";
+        }>;
+        digestHourUTC: z.ZodNullable<z.ZodNumber>;
+        digestWeekday: z.ZodNullable<z.ZodNumber>;
+        freeGamesEnabled: z.ZodBoolean;
+        freeDlcEnabled: z.ZodBoolean;
+        freeGameStores: z.ZodArray<z.ZodEnum<{
+            steam: "steam";
+            epic: "epic";
+            gog: "gog";
+            prime: "prime";
+        }>>;
+        upcomingFreeEnabled: z.ZodBoolean;
+        freeWeekendEnabled: z.ZodBoolean;
+        discountsEnabled: z.ZodBoolean;
+        discountStores: z.ZodArray<z.ZodEnum<{
+            steam: "steam";
+            epic: "epic";
+            gog: "gog";
+            prime: "prime";
+        }>>;
+        minDiscountPercent: z.ZodNullable<z.ZodNumber>;
+        maxPriceCents: z.ZodNullable<z.ZodNumber>;
+        genres: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        studios: z.ZodArray<z.ZodString>;
+        allTimeLowEnabled: z.ZodBoolean;
+        allTimeLowMaxPriceCents: z.ZodNullable<z.ZodNumber>;
+        changelogChannelId: z.ZodNullable<z.ZodString>;
+        changelogPingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+        categoryRoutes: z.ZodArray<z.ZodLazy<z.ZodObject<{
+            kinds: z.ZodArray<z.ZodEnum<{
+                free_game: "free_game";
+                free_dlc_or_loot: "free_dlc_or_loot";
+                discount: "discount";
+                upcoming_free: "upcoming_free";
+            }>>;
+            stores: z.ZodArray<z.ZodEnum<{
+                steam: "steam";
+                epic: "epic";
+                gog: "gog";
+                prime: "prime";
+            }>>;
+            flags: z.ZodArray<z.ZodEnum<{
+                freeWeekend: "freeWeekend";
+                allTimeLow: "allTimeLow";
+                featured: "featured";
+                aaa: "aaa";
+                earlyAccess: "earlyAccess";
+            }>>;
+            genres: z.ZodArray<z.ZodString>;
+            tags: z.ZodArray<z.ZodString>;
+            minDiscountPercent: z.ZodNullable<z.ZodNumber>;
+            channelId: z.ZodNullable<z.ZodString>;
+            pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+            webhookEnabled: z.ZodNullable<z.ZodBoolean>;
+            webhookUsername: z.ZodNullable<z.ZodString>;
+            webhookAvatarUrl: z.ZodNullable<z.ZodString>;
+            priority: z.ZodNumber;
+        }, z.core.$strip>>>;
+        trackedGames: z.ZodArray<z.ZodLazy<z.ZodObject<{
+            steamAppId: z.ZodNullable<z.ZodNumber>;
+            title: z.ZodNullable<z.ZodString>;
+            itemId: z.ZodNullable<z.ZodString>;
+            channelId: z.ZodNullable<z.ZodString>;
+            pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+            minDiscountPercent: z.ZodNullable<z.ZodNumber>;
+            atlOnly: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        changelogGames: z.ZodArray<z.ZodLazy<z.ZodObject<{
+            steamAppId: z.ZodNumber;
+            title: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    readonly GuildGameCategoryRouteSchema: z.ZodObject<{
+        kinds: z.ZodArray<z.ZodEnum<{
+            free_game: "free_game";
+            free_dlc_or_loot: "free_dlc_or_loot";
+            discount: "discount";
+            upcoming_free: "upcoming_free";
+        }>>;
+        stores: z.ZodArray<z.ZodEnum<{
+            steam: "steam";
+            epic: "epic";
+            gog: "gog";
+            prime: "prime";
+        }>>;
+        flags: z.ZodArray<z.ZodEnum<{
+            freeWeekend: "freeWeekend";
+            allTimeLow: "allTimeLow";
+            featured: "featured";
+            aaa: "aaa";
+            earlyAccess: "earlyAccess";
+        }>>;
+        genres: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        minDiscountPercent: z.ZodNullable<z.ZodNumber>;
+        channelId: z.ZodNullable<z.ZodString>;
+        pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+        webhookEnabled: z.ZodNullable<z.ZodBoolean>;
+        webhookUsername: z.ZodNullable<z.ZodString>;
+        webhookAvatarUrl: z.ZodNullable<z.ZodString>;
+        priority: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly GuildTrackedGameSchema: z.ZodObject<{
+        steamAppId: z.ZodNullable<z.ZodNumber>;
+        title: z.ZodNullable<z.ZodString>;
+        itemId: z.ZodNullable<z.ZodString>;
+        channelId: z.ZodNullable<z.ZodString>;
+        pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+        minDiscountPercent: z.ZodNullable<z.ZodNumber>;
+        atlOnly: z.ZodBoolean;
+    }, z.core.$strip>;
+    readonly GuildGameChangelogSchema: z.ZodObject<{
+        steamAppId: z.ZodNumber;
+        title: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+};
+export declare const GameConfigZodPartial: PartialZodObject<typeof GameConfigZod>;