@duque.edits/sdk 0.1.4 → 0.1.6

package/{dist → types}/managers/match/GuildMatchManager.d.ts

@@ -1,32 +1,30 @@
-import { REST } from "../../rest/REST";
 import { GuildMatch } from "../../structures/match/GuildMatch";
 import { Collection } from "../../structures/Collection";
 import { Guild } from "../../structures/guild/Guild";
 import { APIGuildMatch } from "../../types/api/APIGuildMatch";
 import { Optional } from "../../types/api";
-export declare class GuildMatchManager {
-    /** A cache of users */
-    cache: Collection<string, GuildMatch>;
-    /** The rest client */
-    rest: REST;
-    /** GuildMatch match guild */
-    guild: Guild;
+import { BaseManager } from "../base";
+type FetchOptions = {
+    cache: boolean;
+    matchId: string;
+};
+export declare class GuildMatchManager extends BaseManager<GuildMatch> {
     /**
      * Manage users with the given client
      * @param users An array of users
      * @param rest The rest client
      */
-    constructor(guild: Guild, rest: REST);
+    constructor(guild: Guild);
     /**
      * Fetch a match
      * @param id Id of the match to fetch
      * @returns APIBetUser
      */
-    fetch(id: string): Promise<GuildMatch>;
+    fetch(options?: Optional<FetchOptions>): Promise<GuildMatch | Collection<string, GuildMatch>>;
     fetchAll(): Promise<Collection<string, GuildMatch>>;
-    set(data: APIGuildMatch): GuildMatch;
-    setAll(data: APIGuildMatch[]): Collection<string, GuildMatch>;
+    set(data: APIGuildMatch | APIGuildMatch[]): GuildMatch | Collection<string, GuildMatch>;
     create(payload: Optional<APIGuildMatch>): Promise<GuildMatch>;
     delete(id: string): Promise<Collection<string, GuildMatch>>;
     deleteAll(): Promise<boolean>;
 }
+export {};

package/types/managers/message/MessagesManager.d.ts

@@ -0,0 +1,17 @@
+import { REST } from "../../rest";
+import { Collection } from "../../structures/Collection";
+import { APIMessage, Optional } from "../../types";
+type T<e> = e & {
+    rest: REST;
+    messages: MessagesManager<e>;
+};
+export declare class MessagesManager<Structure> {
+    cache: Collection<string, APIMessage>;
+    readonly base_url: string;
+    readonly rest: REST;
+    constructor(structure: T<Structure>, base_url: string);
+    fetch(): Promise<APIMessage>;
+    create(data: Optional<APIMessage> | Optional<APIMessage>[]): Promise<APIMessage[]>;
+    setAll(data: APIMessage | APIMessage[]): Collection<string, APIMessage>;
+}
+export {};

package/types/managers/permission/GuildPermissionManager.d.ts

@@ -0,0 +1,8 @@
+import { Guild } from "../../structures/guild/Guild";
+import { APIGuild, APIGuildPermissions } from "../../types";
+import { BaseManager } from "../base";
+export declare class GuildPermissionManager extends BaseManager<APIGuildPermissions> {
+    constructor(guild: Guild);
+    addRole(permissionId: keyof APIGuildPermissions, roleId: string): Promise<APIGuild | Guild>;
+    removeRole(permissionId: keyof APIGuildPermissions, roleId: string): Promise<APIGuild | Guild>;
+}

package/types/managers/ticket/TicketManager.d.ts

@@ -0,0 +1,22 @@
+import { REST } from "../../rest";
+import { Guild, GuildTicket } from "../../structures";
+import { Collection } from "../../structures/Collection";
+import { APIGuildTicket, Optional } from "../../types";
+type FecthOptions = {
+    ticketId?: string;
+    cache?: boolean;
+};
+type DeleteOptions = {
+    ticketId?: string;
+};
+export declare class TicketManager {
+    cache: Collection<string, GuildTicket>;
+    readonly guild: Guild;
+    readonly rest: REST;
+    constructor(guild: Guild);
+    fetch(options?: FecthOptions): Promise<GuildTicket | Collection<string, GuildTicket>>;
+    create(data: Optional<APIGuildTicket>): Promise<GuildTicket>;
+    delete(options?: DeleteOptions): Promise<boolean>;
+    set(data: APIGuildTicket | APIGuildTicket[]): GuildTicket | Collection<string, GuildTicket>;
+}
+export {};

package/types/managers/user/GuildUserManager.d.ts

@@ -0,0 +1,19 @@
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { GuildUser } from "../../structures/user/GuildUser";
+import { APIGuildUser } from "../../types";
+import { BaseManager } from "../base";
+type FetchOptions = {
+    userId?: string;
+    cache?: boolean;
+};
+export declare class GuildUserManager extends BaseManager<GuildUser> {
+    constructor(guild: Guild);
+    fetch(options?: FetchOptions): Promise<Collection<string, GuildUser> | GuildUser>;
+    updateMany(users: APIGuildUser[] | GuildUser[]): Promise<Collection<string, GuildUser>>;
+    deleteAll(): Promise<void>;
+    resetAll(): Promise<Collection<string, GuildUser>>;
+    _setUsers(data: (APIGuildUser | GuildUser) | (APIGuildUser[] | GuildUser[])): void;
+    set(data: APIGuildUser | APIGuildUser[]): GuildUser | Collection<string, GuildUser>;
+}
+export {};

package/types/managers/vipmember/VipMemberManager.d.ts

@@ -0,0 +1,33 @@
+import { REST } from "../../rest/REST";
+import { VipMember } from "../../structures/vipmember/VipMember";
+import { Collection } from "../../structures/Collection";
+import { Guild } from "../../structures/guild/Guild";
+import { APIVipMember } from "../../types/api/APIVipMember";
+import { Optional } from "../../types";
+import { BaseManager } from "../base";
+type FecthOptions = {
+    cache?: boolean;
+    memberId?: string;
+};
+export declare class VipMemberManager extends BaseManager<VipMember> {
+    /**
+     * Manage vipmembers with the given client
+     * @param vipmembers An array of vipmembers
+     * @param rest The rest client
+     */
+    constructor(guild: Guild, rest: REST);
+    create(data: Optional<APIVipMember>): Promise<VipMember>;
+    /**
+     * Fetch a member
+     * @param id Id of the member to fetch
+     * @returns VipMember
+     */
+    fetch(options?: FecthOptions): Promise<Collection<string, VipMember> | VipMember>;
+    updateMember(id: string, data: Optional<APIVipMember>): Promise<VipMember>;
+    set(data: APIVipMember): VipMember;
+    setAll(data: APIVipMember[]): Collection<string, VipMember>;
+    resetAll(): Promise<Collection<string, VipMember>>;
+    delete(id: string): Promise<Collection<string, VipMember>>;
+    deleteAll(): Promise<boolean>;
+}
+export {};

package/types/rest/APIEndpoints.d.ts

@@ -0,0 +1,11 @@
+declare class Guild {
+    id: string;
+    tickets: [];
+}
+export declare const APIEndpoints: {
+    readonly "guilds/get": {
+        readonly response: typeof Guild;
+    };
+};
+export type APIEndpoint = keyof typeof APIEndpoints;
+export {};

package/{dist → types}/rest/REST.d.ts

@@ -1,19 +1,9 @@
 import EventEmitter from "events";
 import { GuildManager } from "../managers/guild/GuildManager";
-import { GuildBet } from "../structures/bet/GuildBet";
 import { Collection } from "../structures/Collection";
-import { GuildBetUser } from "../structures/betuser/GuildBetUser";
 import { GuildMatch } from "../structures/match/GuildMatch";
-import { GuildMediator } from "../structures/mediator/GuildMediator";
 import { GuildUser } from "../structures/user/GuildUser";
-interface RequestOptions<Payload> {
-    /** The request's method */
-    method: string;
-    /** The request's url */
-    url: string;
-    /** The request payload */
-    payload?: Payload;
-}
+import { RestEvents, RequestOptions } from "../types/RestTypes";
 /**
  * The main class of this package
  */
@@ -24,11 +14,8 @@ export declare class REST extends EventEmitter {
     key: string;
     /** The guild manager */
     guilds: GuildManager;
-    bets: Collection<string, GuildBet>;
-    matches: Collection<string, GuildMatch>;
-    betUsers: Collection<string, GuildBetUser>;
     users: Collection<string, GuildUser>;
-    mediators: Collection<string, GuildMediator>;
+    matches: Collection<string, GuildMatch>;
     /**
      *
      * @param key The unique key for he client
@@ -41,11 +28,17 @@ export declare class REST extends EventEmitter {
     setKey(key: string): void;
     /** Initialize the caching sistem */
     init(): Promise<this>;
+    /**
+     * Ping the api
+     */
+    ping(): Promise<unknown>;
     /**
      * Request Data from a certain url
      * @param options
      * @returns
      */
     request<Expecting, Payload>(options: RequestOptions<Payload>): Promise<Expecting>;
+    emit<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]): boolean;
+    on<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void): this;
+    once<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void): this;
 }
-export {};

package/{dist → types}/rest/Routes.d.ts

@@ -1,4 +1,4 @@
-export declare const Route: <K>(route: string) => string;
+import { APIGuildTicket } from "../types";
 export declare const Routes: {
     base: string;
     field: (field: string) => string;
@@ -54,7 +54,7 @@ export declare const Routes: {
             update: (guildId: string, ticketId: string) => string;
             delete: (guildId: string, ticketId: string) => string;
             deleteAll: (guildId: string) => string;
-            resource: (guildId: string, ticketId: string, ...resources: string[]) => string;
+            resource: (guildId: string, ticketId: string, ...resources: (keyof APIGuildTicket)[]) => string;
         };
         mediators: {
             getAll: (guildId: string) => string;
@@ -81,4 +81,20 @@ export declare const Routes: {
             };
         };
     };
+    vipmembers: {
+        get: (guildId: string, memberId: string) => string;
+        getAll: (guildId: string) => string;
+        deleteAll: (guildId: string) => string;
+        create: (guildId: string) => string;
+        update: (guildId: string, memberId: string) => string;
+        delete: (guildId: string, memberId: string) => string;
+    };
+    giveaways: {
+        get: (giveawayId: string) => string;
+        getAll: () => string;
+        deleteAll: () => string;
+        create: () => string;
+        update: (giveawayId: string) => string;
+        delete: (giveawayId: string) => string;
+    };
 };

package/types/rest/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./APIEndpoints";
+export * from "./Routes";
+export * from "./REST";

package/{dist → types}/structures/guild/Guild.d.ts

@@ -1,22 +1,15 @@
-import { GuildBetManager } from "../../managers/bet/GuildBetManager";
-import { GuildBetUserManager } from "../../managers/betuser/GuildBetUserManager";
+import { GuildPermissionManager } from "../../managers/permission/GuildPermissionManager";
 import { BufferManager } from "../../managers/buffer/BufferManager";
-import { GroupedChannelManager } from "../../managers/groupedchannel/GroupedChannelManager";
 import { GuildMatchManager } from "../../managers/match/GuildMatchManager";
-import { GuildMediatorManager } from "../../managers/mediator/GuildMediatorManager";
-import { MessagesManager } from "../../managers/messages/MessagesManager";
-import { GuildPermissionManager } from "../../managers/permission/GuildPermissionManager";
-import { GuildTicketManager } from "../../managers/ticket/GuildTicketManager";
-import { GuildUserManager } from "../../managers/user/GuildUserManager";
+import { VipMemberManager } from "../../managers/vipmember/VipMemberManager";
 import { REST } from "../../rest/REST";
-import { Daily, GuildBlacklist } from "../../types/api";
-import { APIGuild, DailyCategories, GuildPrices, GuildScores, GuildStatus, GuildTicketConfiguration } from "../../types/api/APIGuild";
+import { Daily, GuildBlacklist, Optional } from "../../types/api";
+import { APIGuild, DailyCategories, GuildModes, GuildPrices, GuildScores, GuildStatus, GuildTicketConfiguration } from "../../types/api/APIGuild";
 import { APIGuildEmoji } from "../../types/api/APIGuildEmoji";
 import { APIGuildPermissions } from "../../types/api/APIGuildPermissions";
 import { APIGuildRole } from "../../types/api/APIGuildRole";
-import { GuildBetUser } from "../betuser/GuildBetUser";
-import { GuildShop } from "../shop/GuildShop";
-import { GuildUser } from "../user/GuildUser";
+import { GuildUserManager } from "../../managers/user/GuildUserManager";
+import { TicketManager } from "../../managers";
 /** The Guild */
 export declare class Guild {
     /** The data of this guild */
@@ -25,14 +18,14 @@ export declare class Guild {
     rest: REST;
     /** The guild's id */
     id: string;
+    modes: GuildModes;
     /** Guild's client key */
     clientKey: string;
     /** Guild Permissions */
     permissions: APIGuildPermissions;
     /** Guild Ticket */
-    tickets: GuildTicketManager;
     /** Guild Ticket Configuration */
-    ticketsConfiguration: GuildTicketConfiguration;
+    tickets_configuration: GuildTicketConfiguration;
     /** Guild Daily Categories */
     dailyCategories: DailyCategories[];
     /** Guild Scores */
@@ -40,9 +33,7 @@ export declare class Guild {
     /** Guild Status */
     status: GuildStatus;
     /** Guild Channel */
-    channels: GroupedChannelManager;
     /** Guild Categories */
-    categories: GroupedChannelManager;
     /** Guild Blacklist */
     blacklist: GuildBlacklist;
     /** Guild Prefix */
@@ -55,40 +46,37 @@ export declare class Guild {
     createdAt: Date;
     /** Guild Updated Date */
     updatedAt: Date;
-    /** Guild Bets */
-    bets: GuildBetManager;
     /** Guild Users */
-    users: GuildUserManager;
     /** Guild Bet Users */
-    betUsers: GuildBetUserManager;
     /** Guild Matches */
     matches: GuildMatchManager;
-    /** Guild Mediators */
-    mediators: GuildMediatorManager;
-    /** Guild Messages */
-    messages: MessagesManager;
     /** Guild Emojis */
     emojis: APIGuildEmoji[];
     /** Guild Roles */
     roles: APIGuildRole[];
     /** Guild Prices Used */
     prices: GuildPrices;
-    /** Guild Shop */
-    shop: GuildShop;
     permissionsManager: GuildPermissionManager;
     buffer: BufferManager;
+    vipMembers: VipMemberManager;
+    users: GuildUserManager;
+    tickets: TicketManager;
     /**
      * The guild structure
      * @param data The guild's data
      * @param rest The rest client
      */
     constructor(data: APIGuild, rest: REST);
+    _updateInternals(data: Optional<APIGuild>): this;
     fetch(): Promise<Guild>;
-    setBlacklist(value: boolean, user: GuildBetUser | GuildUser, adminId: string): Promise<this>;
-    setStatus(key: keyof GuildStatus, status: string): Promise<this>;
+    update(data: Optional<APIGuild>): Promise<Guild>;
+    setStatus(key: keyof GuildStatus, status: "on" | "off"): Promise<this>;
     addPrice(price: number): Promise<this>;
     removePrice(price: number): Promise<this>;
     setPrefix(prefix: string): Promise<this>;
     addDailyCategory(category: keyof Daily): Promise<this>;
     removeDailyCategory(category: keyof Daily): Promise<this>;
+    setScore(name: AvailableScores, amount: number): Promise<this>;
 }
+type AvailableScores = "win" | "loss" | "mvp" | "creator" | "coin";
+export {};

package/types/structures/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./guild/Guild";
+export * from "./match/GuildMatch";
+export * from "./user/GuildUser";
+export * from "./vipmember/VipMember";
+export * from "./ticket/Ticket";
+export * from "./Collection";

package/{dist → types}/structures/match/GuildMatch.d.ts

@@ -1,43 +1,37 @@
 import { REST } from "../../rest/REST";
 import { Guild } from "../guild/Guild";
-import { APIGuildMatch } from "../../types/api/APIGuildMatch";
+import { APIGuildMatch, MatchSelection } from "../../types/api/APIGuildMatch";
 import { APIPlayer } from "../../types/api/APIPlayer";
-import { APIBetChannel } from "../../types/api/APIBetChannel";
 import { BaseMatchModes, BaseMatchStatus, Confirm, Optional } from "../../types/api";
-import { ChannelManager } from "../../managers/channel/ChannelManager";
 import { GuildMatchManager } from "../../managers/match/GuildMatchManager";
-import { MessagesManager } from "../../managers/messages/MessagesManager";
+import { APIBaseChannel } from "../../types";
+import { MessagesManager } from "../../managers/message/MessagesManager";
 export declare class GuildMatch {
+    _id: string;
+    selections: MatchSelection[];
     /** Match's type */
     type: BaseMatchModes;
+    channels: APIBaseChannel[];
+    guild_id: string;
     /** Match's status */
     status: BaseMatchStatus;
     /** Match's challenge */
     challenge: boolean;
     /** Match's players */
     players: APIPlayer[];
+    teams: APIPlayer[][];
     /** Match's winners */
     winners: APIPlayer[];
     /** Match's losers */
     losers: APIPlayer[];
-    /** Match;s messages */
-    messages: MessagesManager;
-    /** Matches channels */
-    channels: ChannelManager<GuildMatch>;
     /** Match's maximum size */
     maximumSize: number;
     /** Match's kicked out */
     kickedOut: APIPlayer[];
-    /** Match's team a */
-    teamA: APIPlayer[];
-    /** Match's team b */
-    teamB: APIPlayer[];
     /** Match's confirmed */
     confirmed: Confirm[];
     /** Match's leaders */
     leaders: APIPlayer[];
-    /** Match's mvp */
-    mvpId: string;
     /** Match's creator id */
     creatorId: string;
     /** Match's room creator id */
@@ -46,8 +40,9 @@ export declare class GuildMatch {
     createdAt: Date;
     /** Updated Date */
     updatedAt: Date;
+    messages: MessagesManager<GuildMatch>;
     /** Match's id */
-    _id: string;
+    mvps: [];
     manager: GuildMatchManager;
     /** The given guild */
     readonly guild: Guild;
@@ -60,25 +55,20 @@ export declare class GuildMatch {
      * @param guild The guild
      * @param rest The rest client
      */
-    constructor(data: APIGuildMatch, guild: Guild, manager: GuildMatchManager, rest: REST);
+    constructor(data: APIGuildMatch, manager: GuildMatchManager);
     /**
      * Fetches the match
      * @returns New Instance of the match
      */
     fetch(): Promise<GuildMatch>;
-    addMessage(id: string, type: string, content?: string): Promise<boolean>;
     addConfirmed(type: string, id: string): Promise<Confirm>;
     setConfirmed(set: Confirm[]): Promise<GuildMatch>;
     setStatus(status: BaseMatchStatus): Promise<GuildMatch>;
     setWinners(players: Optional<APIPlayer>[] | Optional<APIPlayer>): Promise<GuildMatch>;
     setLoser(players: Optional<APIPlayer>[] | Optional<APIPlayer>): Promise<GuildMatch>;
-    setMvp(userId: string): Promise<GuildMatch>;
+    setMvps(...usersId: string[]): Promise<GuildMatch>;
     setRoomCreatorId(userId: string): Promise<GuildMatch>;
     kick(player: Optional<APIPlayer>): Promise<this>;
-    addChannel(id: string, type: string): Promise<GuildMatch>;
-    setChannels(channels: APIBetChannel[]): Promise<GuildMatch>;
-    addPlayer(id: string, name: string): Promise<GuildMatch>;
-    removePlayer(id: string, name: string): Promise<GuildMatch>;
     update(data: Optional<APIGuildMatch>): Promise<GuildMatch>;
     delete(): Promise<boolean>;
     toJSON(): Record<string, unknown>;

package/types/structures/ticket/Ticket.d.ts

@@ -0,0 +1,30 @@
+import { TicketManager } from "../../managers/ticket/TicketManager";
+import { REST } from "../../rest";
+import { APIGuildTicket, APILogMessage, Optional } from "../../types";
+import { Guild } from "../guild/Guild";
+export declare class GuildTicket implements APIGuildTicket {
+    _id: string;
+    guild_id: string;
+    type: string;
+    status: "on" | "off";
+    admin_id: string;
+    channel_id: string;
+    closed_by_id: string;
+    creator_id: string;
+    customer_rating: number;
+    messages: APILogMessage[];
+    createdAt: Date;
+    updatedAt: Date;
+    readonly rest: REST;
+    readonly guild: Guild;
+    readonly manager: TicketManager;
+    constructor(data: APIGuildTicket, manager: any);
+    fetch(): Promise<GuildTicket>;
+    setCustomerRating(rating: number): Promise<GuildTicket>;
+    setAdminId(id: string): Promise<GuildTicket>;
+    setChannelId(id: string): Promise<GuildTicket>;
+    setClosedById(id: string): Promise<GuildTicket>;
+    setStatus(status: "on" | "off"): Promise<GuildTicket>;
+    addMessage(message: Optional<APILogMessage>): Promise<GuildTicket>;
+    _updateInternals(data: Optional<APIGuildTicket>): this;
+}

package/{dist → types}/structures/user/GuildUser.d.ts

@@ -3,9 +3,9 @@ import { Accessory, Daily, Items, Optional, OriginalChannels } from "../../types
 import { APIGuildUser } from "../../types/api/APIGuildUser";
 import { GuildUserManager } from "../../managers/user/GuildUserManager";
 export declare class GuildUser implements APIGuildUser {
-    #private;
     /** User's id */
     id: string;
+    guild_id: string;
     /** User name */
     name: string;
     /** User's daily */
@@ -25,7 +25,8 @@ export declare class GuildUser implements APIGuildUser {
     /** User's accessories such as double point */
     accessories: Accessory[];
     /** User's original channels */
-    originalChannels: OriginalChannels;
+    original_channels: OriginalChannels;
+    creations: number;
     /** User's items */
     items: Items;
     /** Creation Date */
@@ -42,7 +43,7 @@ export declare class GuildUser implements APIGuildUser {
      * @param manager The manager
      * @param rest The rest client
      */
-    constructor(data: APIGuildUser, manager: GuildUserManager, rest: REST);
+    constructor(data: APIGuildUser, manager: GuildUserManager);
     /** String representation of this user */
     toString(): string;
     /**
@@ -64,6 +65,7 @@ export declare class GuildUser implements APIGuildUser {
      */
     setBlacklist(value: boolean): Promise<this>;
     reset(): Promise<this>;
+    _updateInternals(data: Optional<APIGuildUser>): this;
     /**
      * Update certain property
      * @param data The new data to update with

package/types/structures/vipmember/VipMember.d.ts

@@ -0,0 +1,54 @@
+import { REST } from "../../rest/REST";
+import { Optional } from "../../types/api";
+import { APIVipMember } from "../../types/api/APIVipMember";
+import { VipMemberManager } from "../../managers/vipmember/VipMemberManager";
+import { Guild } from "../guild/Guild";
+export declare class VipMember implements APIVipMember {
+    #private;
+    /** member's id */
+    id: string;
+    /** member name */
+    name: string;
+    /** Members's roleId */
+    roleId: string;
+    /** Members's voiceChannelId */
+    voiceChannelId: string;
+    /** Vip's type */
+    type: "both" | "role" | "channel";
+    /** Member's Guild Id */
+    guild_id: string;
+    duration: Date;
+    status: "on" | "off";
+    /** member's daily */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** The given manager */
+    readonly manager: VipMemberManager;
+    /** The rest client */
+    readonly rest: REST;
+    readonly guild: Guild;
+    /**
+     * Bet member
+     * @param data  The member's data
+     * @param manager The manager
+     * @param rest The rest client
+     */
+    constructor(data: APIVipMember, manager: VipMemberManager);
+    /** String representation of this member */
+    toString(): string;
+    /**
+     * Fetches the member
+     * @returns New Instance of the member
+     */
+    fetch(): Promise<VipMember>;
+    reset(): Promise<this>;
+    /**
+     * Update certain property
+     * @param data The new data to update with
+     * @returns
+     */
+    update(data: Optional<APIVipMember>): Promise<this>;
+    delete(): Promise<boolean>;
+    toJSON(): Record<keyof APIVipMember, unknown>;
+}

package/types/types/RestTypes.d.ts

@@ -0,0 +1,34 @@
+import { Collection } from "../structures/Collection";
+import { Guild } from "../structures/guild/Guild";
+import { GuildMatch } from "../structures/match/GuildMatch";
+import { GuildUser } from "../structures/user/GuildUser";
+export interface RequestOptions<Payload> {
+    /** The request's method */
+    method: string;
+    /** The request's url */
+    url: string;
+    /** The request payload */
+    payload?: Payload;
+}
+export interface RestEvents {
+    request: [{
+        url: string;
+        method: string;
+    }];
+    response: [{
+        status: number;
+        body: unknown;
+    }];
+    error: [Error];
+    debug: [string];
+    matchCreate: [GuildMatch];
+    matchUpdate: [GuildMatch, GuildMatch];
+    matchDelete: [GuildMatch];
+    matchesDelete: [Collection<string, GuildMatch>];
+    guildUpdate: [Guild];
+    guildDelete: [Guild];
+    guildsDelete: [Collection<string, Guild>];
+    userDelete: [GuildUser];
+    userUpdate: [GuildUser];
+    usersDelete: [Collection<string, GuildUser>];
+}

package/types/types/api/APIGiveaway.d.ts

@@ -0,0 +1,27 @@
+export interface GiveawayMessage {
+    id: string;
+    content: string;
+    type: "embed" | "text";
+}
+export interface GiveawayWinners {
+    count: number;
+    selected: string[];
+}
+export interface APIGiveaway {
+    _id: string;
+    host_id: string;
+    channel_id: string;
+    guild_id: string;
+    /** Duration of giveaway in sec */
+    duration: number;
+    prizes: string[];
+    participants: string[];
+    allowed_roles: string[];
+    blacklisted_roles: string[];
+    message: GiveawayMessage;
+    winners: GiveawayWinners;
+    rerolls: string[];
+    status: "created" | "off" | "on";
+    createdAt: Date;
+    updatedAt: Date;
+}