@notidotbot/noti-api-client 1.4.15 → 1.4.17

package/dist/classes/@me.d.ts

@@ -5,7 +5,7 @@ export declare class APIMe {
     private web;
     constructor(web: WebDataManager);
     getCurrentUser({ auth }: MeFunctionsInput['getCurrentUser']): Promise<import("../types").WebResponse<CurrentUser>>;
-    clearCurrentUserNotifications({ auth }: MeFunctionsInput['clearCurrentUserNotifications']): Promise<import("../types").WebResponse<true>>;
+    clearCurrentUserNotifications({ auth }: MeFunctionsInput['clearCurrentUserNotifications']): Promise<import("../types").WebResponse<string>>;
     getCurrentUserGuilds({ auth }: MeFunctionsInput['getCurrentUserGuilds']): Promise<import("../types").WebResponse<CurrentUserGuilds>>;
     getGuildDiscordData<T extends GuildDataType>({ auth, guildId, types, refresh }: MeFunctionsInput['getGuildDiscordData']): Promise<import("../types").WebResponse<DiscordGuildData<T>>>;
     getConnectPlatformUrl({ platform }: MeFunctionsInput['getConnectPlatformUrl']): Promise<import("../types").WebResponse<string>>;
@@ -29,7 +29,6 @@ export type MeFunctionsInput<T extends GuildDataType = never> = {
         refresh?: boolean;
     };
     'getConnectPlatformUrl': {
-        auth: string;
         platform: 'twitch' | 'kick';
     };
     'connectPlatform': {
@@ -81,6 +80,7 @@ export type ModToSomene = {
 export type CurrentUser = {
     isDev: boolean;
     isStaff: boolean;
+    notifications: string[];
     discord: DCUserData;
     database: User & {
         premium: {

package/dist/classes/admin.d.ts

@@ -4,11 +4,15 @@ import { WebDataManager } from '../core/manager';
 export declare class APIAdmin {
     private web;
     constructor(web: WebDataManager);
+    getAdmin({ auth }: AdminFunctionsInput['getAdmin']): Promise<import("../types").WebResponse<string>>;
     getEmailList({ auth }: AdminFunctionsInput['getEmailList']): Promise<import("../types").WebResponse<EmailList>>;
     getAnalytics<T extends string = string>({ auth, lookback }: AdminFunctionsInput['getAnalytics']): Promise<import("../types").WebResponse<Analytics<T, string>>>;
     stripeCharge({ auth, guildId, subscriptionId, amountCents, description, dueDays }: AdminFunctionsInput['stripeCharge']): Promise<import("../types").WebResponse<AdminStripeChargeResponse>>;
 }
 export type AdminFunctionsInput = {
+    'getAdmin': {
+        auth: string;
+    };
     'getEmailList': {
         auth: string;
     };
@@ -26,6 +30,8 @@ export type AdminFunctionsInput = {
     };
 };
 export type AdminGetReturnTypes = {
+    'getAdminRaw': Awaited<ReturnType<APIAdmin['getAdmin']>>;
+    'getAdminSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdmin['getAdmin']>>>;
     'getEmailListRaw': Awaited<ReturnType<APIAdmin['getEmailList']>>;
     'getEmailListSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdmin['getEmailList']>>>;
     'getAnalyticsRaw': Awaited<ReturnType<APIAdmin['getAnalytics']>>;

package/dist/classes/admin.js

@@ -8,6 +8,12 @@ class APIAdmin {
         this.web = web;
     }
     // Methods.
+    async getAdmin({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin'),
+        });
+    }
     async getEmailList({ auth }) {
         return await this.web.request({
             method: 'GET', auth,

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;
@@ -55,6 +55,7 @@ export declare class APIClient {
     getBlog({ identifier }: ClientFunctionsInput['getBlog']): Promise<import("../types").WebResponse<BlogWithout<"reactions">>>;
     createBlog({ auth, body }: ClientFunctionsInput['createBlog']): Promise<import("../types").WebResponse<string>>;
     updateBlog({ auth, identifier, body }: ClientFunctionsInput['updateBlog']): Promise<import("../types").WebResponse<string>>;
+    reactBlog({ auth, identifier }: ClientFunctionsInput['reactBlog']): Promise<import("../types").WebResponse<ReactBlogResponse>>;
     deleteBlog({ auth, identifier }: ClientFunctionsInput['deleteBlog']): Promise<import("../types").WebResponse<string>>;
 }
 export type ClientFunctionsInput = {
@@ -114,6 +115,10 @@ export type ClientFunctionsInput = {
         identifier: string;
         body: Partial<Omit<ClientZod['blogs'][number], BlogToOmitUpdate>>;
     };
+    'reactBlog': {
+        auth: string;
+        identifier: string;
+    };
     'deleteBlog': {
         auth: string;
         identifier: string;
@@ -134,10 +139,28 @@ export type ClientReturnTypes = {
     'deleteFaqSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['deleteFaq']>>>;
     'getNewsRaw': Awaited<ReturnType<APIClient['getNews']>>;
     'getNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getNews']>>>;
+    'getNewsAdminRaw': Awaited<ReturnType<APIClient['getNewsAdmin']>>;
+    'getNewsAdminSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getNewsAdmin']>>>;
     'createNewsRaw': Awaited<ReturnType<APIClient['createNews']>>;
     'createNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['createNews']>>>;
+    'updateNewsRaw': Awaited<ReturnType<APIClient['updateNews']>>;
+    'updateNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['updateNews']>>>;
     'deleteNewsRaw': Awaited<ReturnType<APIClient['deleteNews']>>;
     'deleteNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['deleteNews']>>>;
+    'getBlogsRaw': Awaited<ReturnType<APIClient['getBlogs']>>;
+    'getBlogsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getBlogs']>>>;
+    'getBlogsAdminRaw': Awaited<ReturnType<APIClient['getBlogsAdmin']>>;
+    'getBlogsAdminSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getBlogsAdmin']>>>;
+    'getBlogRaw': Awaited<ReturnType<APIClient['getBlog']>>;
+    'getBlogSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getBlog']>>>;
+    'createBlogRaw': Awaited<ReturnType<APIClient['createBlog']>>;
+    'createBlogSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['createBlog']>>>;
+    'updateBlogRaw': Awaited<ReturnType<APIClient['updateBlog']>>;
+    'updateBlogSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['updateBlog']>>>;
+    'reactBlogRaw': Awaited<ReturnType<APIClient['reactBlog']>>;
+    'reactBlogSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['reactBlog']>>>;
+    'deleteBlogRaw': Awaited<ReturnType<APIClient['deleteBlog']>>;
+    'deleteBlogSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['deleteBlog']>>>;
 };
 export type FaqReturnType = {
     dbId: string;
@@ -152,5 +175,8 @@ export type AskFaqBody = {
     avatarUrl: string;
 };
 export type BlogWithout<T extends keyof Client['blogs'][number] = never> = Omit<Client['blogs'][number], T>;
+export type ReactBlogResponse = {
+    currentReactState: boolean;
+};
 export type BlogToOmitCreate = 'views' | 'reactions' | 'reactionsCount' | 'createdAt' | 'lastEdited';
 export type BlogToOmitUpdate = 'identifier' | BlogToOmitCreate;

package/dist/classes/client.js

@@ -106,6 +106,12 @@ class APIClient {
             endpoint: this.web.qp('/data/blogs/' + identifier),
         });
     }
+    async reactBlog({ auth, identifier }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/data/blogs/' + identifier),
+        });
+    }
     async deleteBlog({ auth, identifier }) {
         return await this.web.request({
             method: 'DELETE', auth,

package/dist/classes/emotes.d.ts

@@ -20,6 +20,8 @@ export type EmotesFunctionsInput = {
 export type EmotesReturnTypes = {
     'getEmotesForRaw': Awaited<ReturnType<APIEmotes['getEmotesFor']>>;
     'getEmotesForSuccess': CancelOutWebResponses<Awaited<ReturnType<APIEmotes['getEmotesFor']>>>;
+    'createDownloadZipRaw': Awaited<ReturnType<APIEmotes['createDownloadZip']>>;
+    'createDownloadZipSuccess': CancelOutWebResponses<Awaited<ReturnType<APIEmotes['createDownloadZip']>>>;
 };
 export type EmojiType = {
     id: 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/classes/guild.d.ts

@@ -9,11 +9,11 @@ export declare class APIGuild {
     getGuild({ auth, guildId }: GuildFunctionsInput['getGuild']): Promise<import("../types").WebResponse<GuildWithStuff>>;
     updateGuild({ auth, guildId, guild }: GuildFunctionsInput['updateGuild']): Promise<import("../types").WebResponse<string>>;
     getCustomBotProfile({ auth, guildId }: GuildFunctionsInput['getCustomBotProfile']): Promise<import("../types").WebResponse<GetCustomBotProfileResponse>>;
-    updateCustomBotProfile({ auth, guildId, formData }: GuildFunctionsInput['updateCustomBotProfile']): Promise<import("../types").WebResponse<CustomBotProfile | null>>;
+    updateCustomBotProfile({ auth, guildId, formData }: GuildFunctionsInput['updateCustomBotProfile']): Promise<import("../types").WebResponse<GetCustomBotProfileResponse>>;
     getGuildErrors({ auth, guildId }: GuildFunctionsInput['getGuildErrors']): Promise<import("../types").WebResponse<GuildErrors>>;
     clearGuildErrors({ auth, guildId }: GuildFunctionsInput['clearGuildErrors']): Promise<import("../types").WebResponse<string>>;
     sendGuildPanelOrNotification<T extends SendPanelType>({ auth, guildId, panel, body }: GuildFunctionsInput<T>['sendGuildPanelOrNotification']): Promise<import("../types").WebResponse<string>>;
-    sendTestKickBotNotification({ auth, guildId, streamer, type }: GuildFunctionsInput['sendTestKickBotNotification']): Promise<import("../types").WebResponse<string>>;
+    sendTestKickBotNotification({ auth, guildId, streamerUserName, type, dontPing }: GuildFunctionsInput['sendTestKickBotNotification']): Promise<import("../types").WebResponse<string>>;
     sendGreetOrBirthdayMessage({ auth, guildId, type }: GuildFunctionsInput['sendGreetOrBirthdayMessage']): Promise<import("../types").WebResponse<string>>;
     createOrUpdateGuildMessage<T extends GuildMessageType, S extends GuildMessageSubType<T>>({ auth, guildId, messageType, messageSubType, data }: GuildFunctionsInput<never, T, S>['createOrUpdateGuildMessage']): Promise<import("../types").WebResponse<string>>;
     deleteGuildMessage<T extends GuildMessageType, S extends GuildMessageSubType<T>>({ auth, guildId, messageType, messageSubType }: GuildFunctionsInput<never, T, S>['deleteGuildMessage']): Promise<import("../types").WebResponse<string>>;
@@ -55,8 +55,9 @@ export type GuildFunctionsInput<T extends SendPanelType = never, T2 extends Guil
     'sendTestKickBotNotification': {
         auth: string;
         guildId: string;
-        streamer: string;
+        streamerUserName: string;
         type: 'vod' | 'clip';
+        dontPing?: boolean;
     };
     'getGuildErrors': {
         auth: string;

package/dist/classes/guild.js

@@ -53,11 +53,12 @@ class APIGuild {
             endpoint: this.web.qp('/data/guild/' + guildId + '/panel/' + panel),
         });
     }
-    async sendTestKickBotNotification({ auth, guildId, streamer, type }) {
+    async sendTestKickBotNotification({ auth, guildId, streamerUserName, type, dontPing }) {
         return await this.web.request({
             method: 'PUT', auth,
+            body: { streamerUserName },
             endpoint: this.web.qp('/data/guild/' + guildId + '/kickbot/' + type, {
-                streamerUserName: streamer,
+                dontPing: dontPing,
             }),
         });
     }

package/dist/classes/guildDrops.d.ts

@@ -31,6 +31,7 @@ export type GuildDropsFunctionsInput = {
         } | null;
         games?: Array<{
             id: string | null;
+            dbId?: string | null;
             channelId?: string | null;
             roleId?: string | null;
             liveNotifications?: boolean | null;

package/dist/classes/guildGiveaway.d.ts

@@ -78,8 +78,10 @@ export type GuildGiveawayFunctionsInput<T extends WhenCreate = never> = {
     };
 };
 export type GuildGiveawayReturnTypes = {
-    'getGuildStreamersRaw': Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaways']>>;
-    'getGuildStreamersSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaways']>>>;
+    'getGuildGiveawaysRaw': Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaways']>>;
+    'getGuildGiveawaysSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaways']>>>;
+    'getGuildGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaway']>>;
+    'getGuildGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaway']>>>;
     'getGuildGiveawayEntriesRaw': Awaited<ReturnType<APIGuildGiveaway['getGuildGiveawayEntries']>>;
     'getGuildGiveawayEntriesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['getGuildGiveawayEntries']>>>;
     'createGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['createGiveaway']>>;
@@ -88,6 +90,8 @@ export type GuildGiveawayReturnTypes = {
     'updateGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['updateGiveaway']>>>;
     'resendGiveawayMessageRaw': Awaited<ReturnType<APIGuildGiveaway['resendGiveawayMessage']>>;
     'resendGiveawayMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['resendGiveawayMessage']>>>;
+    'startScheduledGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['startScheduledGiveaway']>>;
+    'startScheduledGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['startScheduledGiveaway']>>>;
     'deleteGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['deleteGiveaway']>>;
     'deleteGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['deleteGiveaway']>>>;
     'endGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['endGiveaway']>>;