@notidotbot/noti-api-client 1.4.0

package/dist/classes/files.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIFiles = void 0;
+// Data.
+class APIFiles {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getFiles({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/files'),
+        });
+    }
+    async uploadFile({ auth, key, file }) {
+        const formData = new FormData();
+        formData.append('key', key);
+        formData.append('file', file);
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/data/files'),
+            body: formData,
+            headers: null,
+            doNotStringify: true,
+        });
+    }
+    async deleteFile({ auth, key }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/files/' + key),
+        });
+    }
+}
+exports.APIFiles = APIFiles;

package/dist/classes/guild.d.ts

@@ -0,0 +1,187 @@
+import { GuildMessageTypeEnum, GuildSingleMessageTypeEnum } from '@prisma/client';
+import { CancelOutWebResponses, DeepPartial } from '../types';
+import { Guild, GuildZod } from '../other/prisma';
+import { WebDataManager } from '../core/manager';
+import { AddonNames } from '../modules/stripe';
+export declare class APIGuild {
+    private web;
+    constructor(web: WebDataManager);
+    getGuild({ auth, guildId }: GuildFunctionsInput['getGuild']): Promise<import("../types").WebResponse<GuildWithStuff>>;
+    updateGuild({ auth, guildId, guild }: GuildFunctionsInput['updateGuild']): Promise<import("../types").WebResponse<string>>;
+    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>>;
+    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>>;
+    createOrUpdateGuildRoles<T extends GuildRoleType>({ auth, guildId, type, roleId, data }: GuildFunctionsInput<never, never, never, T>['createOrUpdateGuildRoles']): Promise<import("../types").WebResponse<string>>;
+    deleteGuildRoles<T extends GuildRoleType>({ auth, guildId, type, roleId }: GuildFunctionsInput<never, never, never, T>['deleteGuildRoles']): Promise<import("../types").WebResponse<string>>;
+    createOrUpdateOverride({ auth, guildId, priorityOnConflict, data }: GuildFunctionsInput['createOrUpdateOverride']): Promise<import("../types").WebResponse<string>>;
+    deleteOverride({ auth, guildId, priorityOnConflict }: GuildFunctionsInput['deleteOverride']): Promise<import("../types").WebResponse<string>>;
+    createOrUpdateStickyMessage({ auth, guildId, data, channelId }: GuildFunctionsInput['createOrUpdateStickyMessage']): Promise<import("../types").WebResponse<string>>;
+    deleteStickyMessage({ auth, guildId, channelId }: GuildFunctionsInput['deleteStickyMessage']): Promise<import("../types").WebResponse<string>>;
+    createOrUpdateLinkedRole({ auth, guildId, data, roleId }: GuildFunctionsInput['createOrUpdateLinkedRole']): Promise<import("../types").WebResponse<string>>;
+    deleteLinkedRole({ auth, guildId, roleId }: GuildFunctionsInput['deleteLinkedRole']): Promise<import("../types").WebResponse<string>>;
+}
+export type GuildFunctionsInput<T extends SendPanelType = never, T2 extends GuildMessageType = never, S extends GuildMessageSubType<T2> = never, T3 extends GuildRoleType = never> = {
+    'getGuild': {
+        auth: string;
+        guildId: string;
+    };
+    'updateGuild': {
+        auth: string;
+        guildId: string;
+        guild: DeepPartial<GuildZod>;
+    };
+    'sendGuildPanelOrNotification': {
+        auth: string;
+        guildId: string;
+        panel: T;
+        body: SendPanelBody<T>;
+        dontPing?: boolean;
+    };
+    'sendTestKickBotNotification': {
+        auth: string;
+        guildId: string;
+        streamer: string;
+        type: 'vod' | 'clip';
+    };
+    'getGuildErrors': {
+        auth: string;
+        guildId: string;
+    };
+    'clearGuildErrors': {
+        auth: string;
+        guildId: string;
+    };
+    'createOrUpdateGuildMessage': {
+        auth: string;
+        guildId: string;
+        messageType: T2;
+        messageSubType: S;
+        data: GuildMessageBody<T2>;
+    };
+    'deleteGuildMessage': {
+        auth: string;
+        guildId: string;
+        messageType: T2;
+        messageSubType: S;
+    };
+    'createOrUpdateGuildRoles': {
+        auth: string;
+        guildId: string;
+        type: T3;
+        roleId: string;
+        data: GuildRoleBody<T3>;
+    };
+    'deleteGuildRoles': {
+        auth: string;
+        guildId: string;
+        type: T3;
+        roleId: string;
+    };
+    'createOrUpdateOverride': {
+        auth: string;
+        guildId: string;
+        priorityOnConflict: number;
+        data: GuildZod['notificationOverrides'][number];
+    };
+    'deleteOverride': {
+        auth: string;
+        guildId: string;
+        priorityOnConflict: number;
+    };
+    'createOrUpdateStickyMessage': {
+        auth: string;
+        guildId: string;
+        channelId: string;
+        data: GuildZod['stickyMessages'][number];
+    };
+    'deleteStickyMessage': {
+        auth: string;
+        guildId: string;
+        channelId: string;
+    };
+    'createOrUpdateLinkedRole': {
+        auth: string;
+        guildId: string;
+        roleId: string;
+        data: GuildZod['linkedRoles'][number];
+    };
+    'deleteLinkedRole': {
+        auth: string;
+        guildId: string;
+        roleId: string;
+    };
+    'sendGreetOrBirthdayMessage': {
+        auth: string;
+        guildId: string;
+        type: 'welcome' | 'leave' | 'birthday';
+    };
+};
+export type GuildReturnTypes = {
+    'getGuildRaw': Awaited<ReturnType<APIGuild['getGuild']>>;
+    'getGuildSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['getGuild']>>>;
+    'updateGuildRaw': Awaited<ReturnType<APIGuild['updateGuild']>>;
+    'updateGuildSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['updateGuild']>>>;
+    'sendGuildPanelOrNotificationRaw': Awaited<ReturnType<APIGuild['sendGuildPanelOrNotification']>>;
+    'sendGuildPanelOrNotificationSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['sendGuildPanelOrNotification']>>>;
+    'sendTestKickBotNotificationRaw': Awaited<ReturnType<APIGuild['sendTestKickBotNotification']>>;
+    'sendTestKickBotNotificationSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['sendTestKickBotNotification']>>>;
+    'getGuildErrorsRaw': Awaited<ReturnType<APIGuild['getGuildErrors']>>;
+    'getGuildErrorsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['getGuildErrors']>>>;
+    'clearGuildErrorsRaw': Awaited<ReturnType<APIGuild['clearGuildErrors']>>;
+    'clearGuildErrorsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['clearGuildErrors']>>>;
+    'createOrUpdateGuildMessageRaw': Awaited<ReturnType<APIGuild['createOrUpdateGuildMessage']>>;
+    'createOrUpdateGuildMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['createOrUpdateGuildMessage']>>>;
+    'deleteGuildMessageRaw': Awaited<ReturnType<APIGuild['deleteGuildMessage']>>;
+    'deleteGuildMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['deleteGuildMessage']>>>;
+    'createOrUpdateGuildRolesRaw': Awaited<ReturnType<APIGuild['createOrUpdateGuildRoles']>>;
+    'createOrUpdateGuildRolesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['createOrUpdateGuildRoles']>>>;
+    'deleteGuildRolesRaw': Awaited<ReturnType<APIGuild['deleteGuildRoles']>>;
+    'deleteGuildRolesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['deleteGuildRoles']>>>;
+    'createOrUpdateOverrideRaw': Awaited<ReturnType<APIGuild['createOrUpdateOverride']>>;
+    'createOrUpdateOverrideSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['createOrUpdateOverride']>>>;
+    'deleteOverrideRaw': Awaited<ReturnType<APIGuild['deleteOverride']>>;
+    'deleteOverrideSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['deleteOverride']>>>;
+    'createOrUpdateStickyMessageRaw': Awaited<ReturnType<APIGuild['createOrUpdateStickyMessage']>>;
+    'createOrUpdateStickyMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['createOrUpdateStickyMessage']>>>;
+    'deleteStickyMessageRaw': Awaited<ReturnType<APIGuild['deleteStickyMessage']>>;
+    'deleteStickyMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['deleteStickyMessage']>>>;
+    'createOrUpdateLinkedRoleRaw': Awaited<ReturnType<APIGuild['createOrUpdateLinkedRole']>>;
+    'createOrUpdateLinkedRoleSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['createOrUpdateLinkedRole']>>>;
+    'deleteLinkedRoleRaw': Awaited<ReturnType<APIGuild['deleteLinkedRole']>>;
+    'deleteLinkedRoleSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['deleteLinkedRole']>>>;
+    'sendGreetOrBirthdayMessageRaw': Awaited<ReturnType<APIGuild['sendGreetOrBirthdayMessage']>>;
+    'sendGreetOrBirthdayMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuild['sendGreetOrBirthdayMessage']>>>;
+};
+export type SendPanelType = 'sync' | 'kickLeaderboard' | 'statCounters' | 'birthday';
+export type SendPanelBody<T extends SendPanelType> = T extends 'sync' ? {
+    syncChannel: string;
+    platform: 'kick';
+} : T extends 'kickLeaderboard' ? {
+    streamerUserName: string;
+    leaderBoardChannelId?: string;
+    leaderBoardTypes?: ('weekly' | 'monthly' | 'overall')[];
+} : T extends 'statCounters' ? {
+    streamerUserName: string;
+    platform: 'kick';
+    types: ('followers' | 'liveUpdates')[];
+} : T extends 'birthday' ? {
+    birthdayChannelId?: string;
+} : never;
+export type GuildErrors = {
+    time: number;
+    message: string;
+    missingPermissions?: string[];
+}[];
+export type GuildWithStuff = Guild & {
+    isPremium: boolean;
+    limits: Record<`max${AddonNames extends string ? AddonNames : never}`, number>;
+};
+export type GuildMessageType = 'customMessages' | 'singleMessages' | 'randomMessages';
+export type GuildMessageSubType<T extends GuildMessageType> = T extends 'customMessages' ? GuildMessageTypeEnum : T extends 'singleMessages' ? GuildSingleMessageTypeEnum : T extends 'randomMessages' ? GuildMessageTypeEnum : never;
+export type GuildMessageBody<T extends GuildMessageType> = T extends 'customMessages' ? GuildZod['messages'][number] : T extends 'singleMessages' ? GuildZod['singleMessages'][number] : T extends 'randomMessages' ? GuildZod['randomMessages'][number] : never;
+export type GuildRoleType = 'statusRoles' | 'autoLiveRoles';
+export type GuildRoleBody<T extends GuildRoleType> = T extends 'statusRoles' ? GuildZod['statusRoles'][number] : T extends 'autoLiveRoles' ? GuildZod['autoLiveRoles'][number] : never;

package/dist/classes/guild.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuild = void 0;
+// Data.
+class APIGuild {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getGuild({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId),
+        });
+    }
+    async updateGuild({ auth, guildId, guild }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: guild,
+            endpoint: this.web.qp('/data/guild/' + guildId),
+        });
+    }
+    async getGuildErrors({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/errors'),
+        });
+    }
+    async clearGuildErrors({ auth, guildId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/errors'),
+        });
+    }
+    async sendGuildPanelOrNotification({ auth, guildId, panel, body }) {
+        return await this.web.request({
+            method: 'PUT', auth, body,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/panel/' + panel),
+        });
+    }
+    async sendTestKickBotNotification({ auth, guildId, streamer, type }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/kickbot/' + type, {
+                streamerUserName: streamer,
+            }),
+        });
+    }
+    async sendGreetOrBirthdayMessage({ auth, guildId, type }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp('/data/guild/' + guildId + '/greet/' + type),
+        });
+    }
+    async createOrUpdateGuildMessage({ auth, guildId, messageType, messageSubType, data }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/messages`, {
+                type: messageType,
+                subType: messageSubType,
+            }),
+        });
+    }
+    async deleteGuildMessage({ auth, guildId, messageType, messageSubType }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/messages`, {
+                type: messageType,
+                subType: messageSubType,
+            }),
+        });
+    }
+    async createOrUpdateGuildRoles({ auth, guildId, type, roleId, data }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/roles`, {
+                type: type,
+                roleId: roleId,
+            }),
+        });
+    }
+    async deleteGuildRoles({ auth, guildId, type, roleId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/roles`, {
+                type: type,
+                roleId: roleId,
+            }),
+        });
+    }
+    async createOrUpdateOverride({ auth, guildId, priorityOnConflict, data }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/overrides`, {
+                priorityOnConflict: priorityOnConflict,
+            }),
+        });
+    }
+    async deleteOverride({ auth, guildId, priorityOnConflict }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/overrides`, {
+                priorityOnConflict: priorityOnConflict,
+            }),
+        });
+    }
+    async createOrUpdateStickyMessage({ auth, guildId, data, channelId }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/stickyMessages`, {
+                channelId: channelId,
+            }),
+        });
+    }
+    async deleteStickyMessage({ auth, guildId, channelId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/stickyMessages`, {
+                channelId: channelId,
+            }),
+        });
+    }
+    async createOrUpdateLinkedRole({ auth, guildId, data, roleId }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: data,
+            endpoint: this.web.qp(`/data/guild/${guildId}/linkedRoles`, {
+                roleId: roleId,
+            }),
+        });
+    }
+    async deleteLinkedRole({ auth, guildId, roleId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/linkedRoles`, {
+                roleId: roleId,
+            }),
+        });
+    }
+}
+exports.APIGuild = APIGuild;

package/dist/classes/guildDrops.d.ts

@@ -0,0 +1,58 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APIGuildDrops {
+    private web;
+    constructor(web: WebDataManager);
+    getGuildDrops({ auth, guildId }: GuildDropsFunctionsInput['getGuildDrops']): Promise<import("../types").WebResponse<GuildDropsData>>;
+    updateGuildDrops({ auth, guildId, kickEnabled, twitchEnabled, liveNotifications, channelId, roleId, webhook }: GuildDropsFunctionsInput['updateGuildDrops']): Promise<import("../types").WebResponse<GuildDropsData>>;
+}
+export type GuildDropsFunctionsInput = {
+    'getGuildDrops': {
+        auth: string;
+        guildId: string;
+    };
+    'updateGuildDrops': {
+        auth: string;
+        guildId: string;
+        kickEnabled?: boolean;
+        twitchEnabled?: boolean;
+        liveNotifications?: boolean;
+        channelId?: string | null;
+        roleId?: string | null;
+        webhook?: {
+            username?: string | null;
+            avatarUrl?: string | null;
+        } | null;
+    };
+};
+export type GuildDropsReturnTypes = {
+    'getGuildDropsRaw': Awaited<ReturnType<APIGuildDrops['getGuildDrops']>>;
+    'getGuildDropsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildDrops['getGuildDrops']>>>;
+    'updateGuildDropsRaw': Awaited<ReturnType<APIGuildDrops['updateGuildDrops']>>;
+    'updateGuildDropsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildDrops['updateGuildDrops']>>>;
+};
+export type WebhookConfig = {
+    avatarUrl: string | null;
+    username: string | null;
+};
+export type GameDropConfig = {
+    id: string | null;
+    name: string | null;
+    slug: string | null;
+    imageUrl: string | null;
+    description: string | null;
+    platform: string | null;
+    channelId: string | null;
+    roleId: string | null;
+    liveNotifications: boolean | null;
+    webhook: WebhookConfig | null;
+};
+export type GuildDropsData = {
+    kickEnabled: boolean;
+    twitchEnabled: boolean;
+    liveNotifications: boolean;
+    channelId: string | null;
+    roleId: string | null;
+    webhook: WebhookConfig;
+    games: GameDropConfig[];
+};

package/dist/classes/guildDrops.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildDrops = void 0;
+// Data.
+class APIGuildDrops {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getGuildDrops({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/drops`),
+        });
+    }
+    async updateGuildDrops({ auth, guildId, kickEnabled, twitchEnabled, liveNotifications, channelId, roleId, webhook }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/drops`),
+            body: {
+                kickEnabled,
+                twitchEnabled,
+                liveNotifications,
+                channelId,
+                roleId,
+                webhook,
+            },
+        });
+    }
+}
+exports.APIGuildDrops = APIGuildDrops;

package/dist/classes/guildGiveaway.d.ts

@@ -0,0 +1,110 @@
+import { GuildGiveaway, GuildGiveawayCreateSchema, GuildGiveawayZod } from '../other/prisma';
+import { CancelOutWebResponses, DeepPartial } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APIGuildGiveaway {
+    private web;
+    constructor(web: WebDataManager);
+    getGuildGiveaways({ auth, guildId }: GuildGiveawayFunctionsInput['getGuildGiveaways']): Promise<import("../types").WebResponse<GuildGiveawaysType>>;
+    getGuildGiveaway({ auth, guildId, giveawayId }: GuildGiveawayFunctionsInput['getGuildGiveaway']): Promise<import("../types").WebResponse<GuildGiveawayWithEntry>>;
+    getGuildGiveawayEntries({ auth, guildId, giveawayId }: GuildGiveawayFunctionsInput['getGuildGiveawayEntries']): Promise<import("../types").WebResponse<{
+        dbId: string;
+        entries: number;
+        username: string;
+        userId: string;
+        guildGiveawayId: string;
+    }[]>>;
+    createGiveaway<T extends WhenCreate>({ auth, guildId, body, when }: GuildGiveawayFunctionsInput<T>['createGiveaway']): Promise<import("../types").WebResponse<string>>;
+    updateGiveaway({ auth, guildId, giveawayId, body }: GuildGiveawayFunctionsInput['updateGiveaway']): Promise<import("../types").WebResponse<string>>;
+    resendGiveawayMessage({ auth, guildId, giveawayId }: GuildGiveawayFunctionsInput['resendGiveawayMessage']): Promise<import("../types").WebResponse<string>>;
+    startScheduledGiveaway({ auth, guildId, giveawayId }: GuildGiveawayFunctionsInput['startScheduledGiveaway']): Promise<import("../types").WebResponse<string>>;
+    endGiveaway({ auth, guildId, giveawayId }: GuildGiveawayFunctionsInput['endGiveaway']): Promise<import("../types").WebResponse<string>>;
+    rerollGiveaway({ auth, guildId, giveawayId }: GuildGiveawayFunctionsInput['rerollGiveaway']): Promise<import("../types").WebResponse<string>>;
+    deleteGiveaway({ auth, guildId, giveawayId, type }: GuildGiveawayFunctionsInput['deleteGiveaway']): Promise<import("../types").WebResponse<string>>;
+}
+export type GuildGiveawayFunctionsInput<T extends WhenCreate = never> = {
+    'getGuildGiveaways': {
+        auth: string;
+        guildId: string;
+    };
+    'getGuildGiveaway': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+    };
+    'startScheduledGiveaway': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+    };
+    'getGuildGiveawayEntries': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+    };
+    'createGiveaway': {
+        auth: string;
+        guildId: string;
+        body: GuildGiveawayCreateSchema & {
+            startInMinutes: T extends 'later' ? number : 0;
+        };
+        when: T;
+    };
+    'updateGiveaway': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+        body: Pick<DeepPartial<GuildGiveawayZod>, 'winnerCount' | 'durationMinutes' | 'name'>;
+    };
+    'resendGiveawayMessage': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+    };
+    'deleteGiveaway': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+        type: StateType;
+    };
+    'endGiveaway': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+    };
+    'rerollGiveaway': {
+        auth: string;
+        guildId: string;
+        giveawayId: string;
+    };
+};
+export type GuildGiveawayReturnTypes = {
+    'getGuildStreamersRaw': Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaways']>>;
+    'getGuildStreamersSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['getGuildGiveaways']>>>;
+    'getGuildGiveawayEntriesRaw': Awaited<ReturnType<APIGuildGiveaway['getGuildGiveawayEntries']>>;
+    'getGuildGiveawayEntriesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['getGuildGiveawayEntries']>>>;
+    'createGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['createGiveaway']>>;
+    'createGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['createGiveaway']>>>;
+    'updateGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['updateGiveaway']>>;
+    'updateGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['updateGiveaway']>>>;
+    'resendGiveawayMessageRaw': Awaited<ReturnType<APIGuildGiveaway['resendGiveawayMessage']>>;
+    'resendGiveawayMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['resendGiveawayMessage']>>>;
+    'deleteGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['deleteGiveaway']>>;
+    'deleteGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['deleteGiveaway']>>>;
+    'endGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['endGiveaway']>>;
+    'endGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['endGiveaway']>>>;
+    'rerollGiveawayRaw': Awaited<ReturnType<APIGuildGiveaway['rerollGiveaway']>>;
+    'rerollGiveawaySuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildGiveaway['rerollGiveaway']>>>;
+};
+export type WhenCreate = 'now' | 'later';
+export type StateType = 'live' | 'scheduled';
+export type GuildGiveawaysType = {
+    existing: GuildGiveawayWithEntry[];
+    scheduled: {
+        data: GuildGiveawayCreateSchema;
+        shouldStartAt: Date;
+    }[];
+};
+export type GuildGiveawayEntriesType = GuildGiveaway['currentEntries'];
+export type GuildGiveawayWithEntry = Omit<GuildGiveaway, 'currentEntries'> & {
+    currentEntries: number;
+};

package/dist/classes/guildGiveaway.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildGiveaway = void 0;
+// Data.
+class APIGuildGiveaway {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getGuildGiveaways({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId),
+        });
+    }
+    async getGuildGiveaway({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId),
+        });
+    }
+    async getGuildGiveawayEntries({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId + '/entries'),
+        });
+    }
+    async createGiveaway({ auth, guildId, body, when }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/giveaways/' + guildId, {
+                when: when,
+            }),
+        });
+    }
+    async updateGiveaway({ auth, guildId, giveawayId, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId),
+        });
+    }
+    async resendGiveawayMessage({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId + '/resend'),
+        });
+    }
+    async startScheduledGiveaway({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId + '/start'),
+        });
+    }
+    async endGiveaway({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId + '/end'),
+        });
+    }
+    async rerollGiveaway({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId + '/reroll'),
+        });
+    }
+    async deleteGiveaway({ auth, guildId, giveawayId, type }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/giveaways/' + guildId + '/' + giveawayId, {
+                type,
+            }),
+        });
+    }
+}
+exports.APIGuildGiveaway = APIGuildGiveaway;