@duque.edits/sdk 1.1.3 → 1.3.1

package/dist/{index-BPxglVSk.d.ts → index-xkfp9hFj.d.ts}

@@ -13,10 +13,11 @@ import { LogEntryTypes, APILogEntry } from './types/api/APILogEntry.js';
 import { APIMessage } from './types/api/APIMessage.js';
 import { APIMinesGame } from './types/api/APIMinesGame.js';
 import { APIPlayer } from './types/api/APIPlayer.js';
-import './types/api/APIProduct.js';
+import { APIProduct } from './types/api/APIProduct.js';
 import { APIVipMember } from './types/api/APIVipMember.js';
 import { Collection } from './structures/Collection.js';
 import EventEmitter from 'events';
+import { APIEmbed } from 'discord-api-types/v10';
 import { APITournament } from './types/api/APITournament.js';
 
 interface APIGuildGroupedChannel {
@@ -120,7 +121,8 @@ declare enum GuildChannelsType {
     BetEmulatorCategory = "bet_emulator_category",
     BetMixCategory = "bet_mix_category",
     RouletteLogs = "roulette_logs",
-    Rules = "rules"
+    Rules = "rules",
+    BettingChannel = "betting"
 }
 interface APIGuild {
     /** Guild's id */
@@ -151,29 +153,53 @@ interface APIGuild {
     createdAt: Date;
     /** Guild Updated Date */
     updatedAt: Date;
-    /** Guild Shop */
-    shop: APIGuildShop;
     adverts: APIGuildAdvert[];
     max_advert_per_user: number;
     codes: APICode[];
     coin_symbol: string;
     roulette_settings: RouletteSettings;
+    webhook_urls: GuildLogsWebhookUrls;
     autorole_config: {
         role: string;
     };
-    automatic_messages: APIAutomaticMessage[];
+    match_count: number;
+    bet_count: number;
+}
+interface GuildLogsWebhookUrls {
+    queues: {
+        closed: string;
+        shutted: string;
+        managed: string;
+        started: string;
+    };
+    users: {
+        punished: string;
+        updated: string;
+    };
+    shop: {
+        redeemed: string;
+    };
+    tickets: {
+        closed: string;
+        opened: string;
+    };
 }
 
 interface APIAutomaticMessage {
     id: string;
-    type: AutomaticMessagesTypes;
+    _id: string;
+    name: string;
     admin_id: string;
     channel_ids: string[];
-    content: string;
-    embeds: any[];
-    components: any[];
-    attachments: any[];
-    flags: number;
+    type: AutomaticMessagesTypes;
+    guild_id: string;
+    message: {
+        content: string;
+        embeds: APIEmbed[];
+        components: any[];
+        attachments: any[];
+        flags: number;
+    };
     interval_ms: number;
     createdAt: Date;
     updatedAt: Date;
@@ -249,6 +275,7 @@ interface APIGuildBetUser {
     /** User's coins */
     coins: number;
     spins: number;
+    used_codes: string[];
     /** Creation Date */
     createdAt: Date;
     /** Updated Date */
@@ -272,8 +299,10 @@ interface APIGuildMatch {
     admin_id: string;
     /** Match's players */
     players: APIPlayer[];
+    code: string;
     /** Match's winners */
     winners: APIPlayer[];
+    betting: number;
     /** Match's losers */
     losers: APIPlayer[];
     /** Match;s messages */
@@ -299,7 +328,13 @@ interface APIGuildMatch {
     updatedAt: Date;
     /** Match's id */
     _id: string;
-    mvps: [];
+    mvps: string[];
+    url: string;
+    logs: {
+        shutted: string;
+        closed: string;
+        managed: string;
+    };
 }
 declare enum GuildMatchChannelsType {
     CreationChannel = "creation_channel",
@@ -314,9 +349,15 @@ interface Profile {
     avatarUrl?: string;
     bio?: string;
     name?: string;
+    extra?: string;
     textColor?: string;
     primaryColor?: string;
     secondaryColor?: string;
+    tertiaryColor?: string;
+    booster?: {
+        status?: "on" | "off";
+        expires?: number;
+    };
 }
 interface APIGuildUser {
     /** User's id */
@@ -330,9 +371,11 @@ interface APIGuildUser {
     creations: number;
     /** User's wins */
     wins: number;
+    consecutive_wins: number;
     adverts: APIAdvert[];
     /** User's mvps */
     mvps: number;
+    coins: number;
     /** User's losses */
     losses: number;
     /** User's games */
@@ -344,6 +387,22 @@ interface APIGuildUser {
     /** User's original channels */
     original_channels: OriginalChannels;
     spins: number;
+    used_codes: string[];
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+}
+
+interface APITicketPanel {
+    message: {
+        embeds: APIEmbed[];
+    };
+    name: string;
+    guild_id: string;
+    _id: string;
+    components_type: "button" | "stringselect";
+    categories: APITicketCategory[];
     /** Creation Date */
     createdAt: Date;
     /** Updated Date */
@@ -359,6 +418,9 @@ interface APITicketCategory {
     description: string;
     /** Category's alias */
     alias: string;
+    name: string;
+    role_ids: string[];
+    _id: string;
 }
 interface LogMessage {
     /** The message's content */
@@ -392,19 +454,19 @@ type OriginalChannel = {
 type OriginalChannels = OriginalChannel[];
 /** Accessories */
 type Accessory = {
-    /** Accessory type */
-    type: "point_protect" | "immunity" | "double_points";
-    /** Accessory longevity */
-    longevity: string;
-    /** Accessory adder */
-    addedBy: string;
-    /** When accessory added */
-    when: Date;
-    createdAt: Date;
-    updatedAt: Date;
-    /** If accessory has expired */
-    expired: boolean;
+    type: UserAccessoryType;
+    units: number;
+    time: number;
+    active: {
+        units: number;
+        time: number;
+    };
 };
+declare enum UserAccessoryType {
+    PointsProtection = "points_protection",
+    LossesProtection = "losses_protection",
+    DoublePoints = "double_points"
+}
 /** Daily information */
 type Daily = {
     /** Wins */
@@ -489,14 +551,14 @@ interface StatusResponse {
     timestamp: string;
 }
 
-type FetchOptions$7 = {
+type FetchOptions$9 = {
     userId?: string;
     cache?: boolean;
 };
-type ReturnFetchOptions$5<T extends FetchOptions$7> = T["cache"] extends true ? Collection<string, GuildBetUser> : T["userId"] extends string ? GuildBetUser : Collection<string, GuildBetUser>;
+type ReturnFetchOptions$7<T extends FetchOptions$9> = T["cache"] extends true ? Collection<string, GuildBetUser> : T["userId"] extends string ? GuildBetUser : Collection<string, GuildBetUser>;
 declare class GuildBetUserManager extends BaseManager<GuildBetUser> {
     constructor(guild: Guild);
-    fetch<T extends FetchOptions$7>(options?: T): Promise<ReturnFetchOptions$5<T>>;
+    fetch<T extends FetchOptions$9>(options?: T): Promise<ReturnFetchOptions$7<T>>;
     updateMany(...betusers: Optional<APIGuildBetUser>[]): Promise<Collection<string, GuildBetUser>>;
     deleteAll(): Promise<void>;
     resetAll(): Promise<GuildBetUser | Collection<string, GuildBetUser>>;
@@ -531,6 +593,7 @@ declare class GuildBetUser implements APIGuildBetUser {
     /** Updated Date */
     updatedAt: Date;
     consecutive_wins: number;
+    used_codes: string[];
     /** The given manager */
     readonly manager: GuildBetUserManager;
     /** The rest client */
@@ -571,6 +634,81 @@ declare class GuildBetUser implements APIGuildBetUser {
     toJSON(): Optional<APIGuildBetUser>;
 }
 
+type PlayerOption = APIPlayer[] | APIPlayer;
+type Structure = {
+    guild: Guild;
+    rest: REST;
+};
+declare class PlayerManager extends Collection<string, APIPlayer> {
+    base_url: string;
+    readonly rest: REST;
+    readonly guild: Guild;
+    constructor(structure: Structure, base_url: string);
+    _set(data: PlayerOption): this;
+    /**
+     * Adds a player or an array of players to the structure.
+     * @param player A player or an array of players to be added
+     * @returns returns a collection of players
+     */
+    add(player: PlayerOption): Promise<this>;
+    /**
+     * Remover a player or an array of players.
+     * @param player The player or an array of players to be removed
+     * @returns Player manager
+     */
+    remove(player: PlayerOption): Promise<this>;
+}
+
+declare class GuildBet {
+    #private;
+    /** The bet's type */
+    type: Omit<BaseMatchModes, "5x5" | "6x6" | "5v5" | "6v6">;
+    /** The bet's mode */
+    mode: "misto" | "emu" | "mob" | "MISTO" | "EMU" | "MOB";
+    /** The bet's status */
+    status: "off" | "created" | "on" | "shutted" | "waiting";
+    /** The bet's maximum size */
+    maximumSize: number;
+    /** The bet's price */
+    price: number;
+    /** The bet's players */
+    players: PlayerManager;
+    teams: APIPlayer[][];
+    /** The bet's channel */
+    channels: APIBetChannel[];
+    /** The bet's messages */
+    messages: MessagesManager<GuildBet>;
+    /** The id of the winner */
+    winners: APIPlayer[];
+    /** The id of the loser */
+    losers: APIPlayer[];
+    /** The bet's creator id */
+    creatorId: string;
+    /** The bet's mediator */
+    mediatorId: string;
+    /** The bet's confirmers */
+    confirmed: Confirm[];
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** Bet's id */
+    _id: string;
+    queues: BetQueue[];
+    guild_id: string;
+    rest: REST;
+    guild: Guild;
+    manager: GuildBetManager;
+    constructor(data: Optional<APIGuildBet>, manager: GuildBetManager);
+    toString(): string;
+    fetch(): Promise<this>;
+    addPlayer(player: APIPlayer, queue_type?: string): Promise<this>;
+    removePlayer(player: APIPlayer): Promise<this>;
+    update(data: Optional<APIGuildBet>): Promise<this>;
+    delete(): Promise<boolean>;
+    toJSON(): Optional<APIGuildBet>;
+}
+
 declare class GuildMatch {
     #private;
     _id: string;
@@ -607,11 +745,18 @@ declare class GuildMatch {
     /** Updated Date */
     updatedAt: Date;
     messages: MessagesManager<GuildMatch>;
-    /** Match's id */
-    mvps: [];
+    mvps: string[];
     manager: GuildMatchManager;
     bet: GuildBet;
     admin_id: string;
+    url: string;
+    code: string;
+    logs: {
+        shutted: string;
+        closed: string;
+        managed: string;
+    };
+    betting: number;
     /** The given guild */
     readonly guild: Guild;
     /** The rest client */
@@ -643,14 +788,14 @@ declare class GuildMatch {
     toJSON(): Optional<APIGuildMatch>;
 }
 
-type FetchOptions$6 = {
+type FetchOptions$8 = {
     userId?: string;
     cache?: boolean;
 };
-type ReturnFetchOptions$4<T extends FetchOptions$6> = T["cache"] extends true ? Collection<string, GuildUser> : T["userId"] extends string ? GuildUser : Collection<string, GuildUser>;
+type ReturnFetchOptions$6<T extends FetchOptions$8> = T["cache"] extends true ? Collection<string, GuildUser> : T["userId"] extends string ? GuildUser : Collection<string, GuildUser>;
 declare class GuildUserManager extends BaseManager<GuildUser> {
     constructor(guild: Guild);
-    fetch<T extends FetchOptions$6>(options?: T): Promise<ReturnFetchOptions$4<T>>;
+    fetch<T extends FetchOptions$8>(options?: T): Promise<ReturnFetchOptions$6<T>>;
     updateMany(...users: Optional<APIGuildUser>[]): Promise<Collection<string, GuildUser>>;
     deleteAll(): Promise<void>;
     resetAll(): Promise<Collection<string, GuildUser>>;
@@ -685,6 +830,9 @@ declare class GuildUser implements APIGuildUser {
     /** User's items */
     adverts: APIAdvert[];
     spins: number;
+    coins: number;
+    consecutive_wins: number;
+    used_codes: string[];
     /** Creation Date */
     createdAt: Date;
     /** Updated Date */
@@ -714,7 +862,23 @@ declare class GuildUser implements APIGuildUser {
      */
     setBlacklist(value: boolean): Promise<this>;
     reset(): Promise<this>;
-    updateProfile(data: Optional<Profile>): Promise<this>;
+    updateProfile(data: Optional<Profile> & {
+        default?: boolean;
+    }): Promise<this>;
+    getAccessory<T extends UserAccessoryType>(type: T): Promise<Accessory>;
+    addAccessory<T extends UserAccessoryType>(type: T, data: Optional<Accessory>): Promise<Accessory>;
+    setAccessory<T extends UserAccessoryType>(type: T, data: Optional<Accessory>): Promise<Accessory>;
+    reduceAccessory<T extends UserAccessoryType>(type: T, data: Optional<Accessory>): Promise<Accessory>;
+    reduceActiveAccessory<T extends UserAccessoryType>(type: T, data: Optional<Accessory>): Promise<Accessory>;
+    activateAccessory(type: UserAccessoryType, data: {
+        time: number;
+        units: number;
+    }): Promise<Accessory>;
+    isAccessoryActive(type: UserAccessoryType): Promise<{
+        value: boolean;
+        type: string;
+    }>;
+    hasAccessory(type: UserAccessoryType): Promise<boolean>;
     addAdvert(data: Optional<Omit<APIAdvert, "_id">>): Promise<GuildUser>;
     removeAdvert(advertId?: string): Promise<GuildUser>;
     /**
@@ -722,11 +886,13 @@ declare class GuildUser implements APIGuildUser {
      * @param data The new data to update with
      * @returns
      */
-    update(data: Omit<Optional<APIGuildUser>, "daily"> & {
+    update(data: Optional<APIGuildUser> & {
         type?: "add" | "remove";
     }): Promise<this>;
+    setUpdate(data: Optional<APIGuildUser>): Promise<this>;
     delete(): Promise<boolean>;
     toJSON(): APIGuildUser;
+    userDailyWrapper(user: Optional<APIGuildUser>): Optional<APIGuildUser>;
 }
 
 interface RequestOptions<Payload> {
@@ -771,79 +937,42 @@ interface RestEvents {
     logEntryCreate: [LogEntry, Guild];
 }
 
-type PlayerOption = APIPlayer[] | APIPlayer;
-type Structure = {
-    guild: Guild;
-    rest: REST;
-};
-declare class PlayerManager extends Collection<string, APIPlayer> {
-    base_url: string;
-    readonly rest: REST;
-    readonly guild: Guild;
-    constructor(structure: Structure, base_url: string);
-    _set(data: PlayerOption): this;
-    /**
-     * Adds a player or an array of players to the structure.
-     * @param player A player or an array of players to be added
-     * @returns returns a collection of players
-     */
-    add(player: PlayerOption): Promise<this>;
-    /**
-     * Remover a player or an array of players.
-     * @param player The player or an array of players to be removed
-     * @returns Player manager
-     */
-    remove(player: PlayerOption): Promise<this>;
-}
-
-declare class GuildBet {
+declare class AutomaticMessage {
     #private;
-    /** The bet's type */
-    type: Omit<BaseMatchModes, "5x5" | "6x6" | "5v5" | "6v6">;
-    /** The bet's mode */
-    mode: "misto" | "emu" | "mob" | "MISTO" | "EMU" | "MOB";
-    /** The bet's status */
-    status: "off" | "created" | "on" | "shutted" | "waiting";
-    /** The bet's maximum size */
-    maximumSize: number;
-    /** The bet's price */
-    price: number;
-    /** The bet's players */
-    players: PlayerManager;
-    teams: APIPlayer[][];
-    /** The bet's channel */
-    channels: APIBetChannel[];
-    /** The bet's messages */
-    messages: MessagesManager<GuildBet>;
-    /** The id of the winner */
-    winners: APIPlayer[];
-    /** The id of the loser */
-    losers: APIPlayer[];
-    /** The bet's creator id */
-    creatorId: string;
-    /** The bet's mediator */
-    mediatorId: string;
-    /** The bet's confirmers */
-    confirmed: Confirm[];
-    /** Creation Date */
+    id: string;
+    type: AutomaticMessagesTypes;
+    name: string;
+    admin_id: string;
+    channel_ids: string[];
+    message: {
+        content: string;
+        embeds: APIEmbed[];
+        components: any[];
+        attachments: any[];
+        flags: number;
+    };
+    guild_id: string;
+    interval_ms: number;
     createdAt: Date;
-    /** Updated Date */
     updatedAt: Date;
-    /** Bet's id */
     _id: string;
-    queues: BetQueue[];
-    guild_id: string;
-    rest: REST;
-    guild: Guild;
-    manager: GuildBetManager;
-    constructor(data: Optional<APIGuildBet>, manager: GuildBetManager);
-    toString(): string;
+    readonly guild: Guild;
+    readonly manager: AutomaticMessageManager;
+    readonly rest: REST;
+    constructor(data: APIAutomaticMessage, manager: AutomaticMessageManager);
     fetch(): Promise<this>;
-    addPlayer(player: APIPlayer, queue_type?: string): Promise<this>;
-    removePlayer(player: APIPlayer): Promise<this>;
-    update(data: Optional<APIGuildBet>): Promise<this>;
+    update(data: Optional<APIAutomaticMessage>): Promise<this>;
     delete(): Promise<boolean>;
-    toJSON(): Optional<APIGuildBet>;
+    setMessage(data: {
+        embeds: APIEmbed[];
+        components: any;
+        attachments: any[];
+        flags: number;
+        content: string;
+    }): Promise<this>;
+    addChannelId(...id: string[]): Promise<this>;
+    removeChannelId(...id: string[]): Promise<this>;
+    toJSON(): APIAutomaticMessage;
 }
 
 declare class LogEntry {
@@ -868,16 +997,30 @@ declare class LogEntry {
     readonly rest: REST;
     constructor(data: APILogEntry, manager: LogManager);
     fetch(): Promise<LogEntry>;
-    toJSON(): Record<string, unknown>;
+    toJSON(): {
+        _id: string;
+        guild_id: string;
+        user_id: string;
+        admin_id: string;
+        object_id: string;
+        type: LogEntryTypes;
+        description: string;
+        change: string;
+        logs_channel_id: string;
+        before: any;
+        after: any;
+        createdAt: Date;
+        updatedAt: Date;
+    };
 }
 
-type FetchOptions$5 = {
+type FetchOptions$7 = {
     mediatorId?: string;
     cache?: boolean;
 };
 declare class GuildMediatorManager extends BaseManager<GuildMediator> {
     constructor(guild: Guild);
-    fetch(options?: FetchOptions$5): Promise<Collection<string, GuildMediator> | GuildMediator>;
+    fetch(options?: FetchOptions$7): Promise<Collection<string, GuildMediator> | GuildMediator>;
     updateMany(...mediators: Optional<APIGuildMediator>[]): Promise<Collection<string, GuildMediator>>;
     create(payload: Optional<APIGuildMediator>): Promise<GuildMediator>;
     deleteAll(): Promise<void>;
@@ -931,6 +1074,94 @@ declare class GuildMediator implements APIGuildMediator {
     toJSON(): Optional<APIGuildMediator>;
 }
 
+type FetchReturn<T> = T extends null ? Collection<string, TicketPanel> : TicketPanel;
+declare class TicketPanelManager extends BaseManager<TicketPanel> {
+    constructor(guild: Guild);
+    create(data: Optional<APITicketPanel>): Promise<TicketPanel>;
+    fetch<T extends string>(id?: T): Promise<FetchReturn<T>>;
+    delete(id?: string): Promise<boolean>;
+    set(data: APITicketPanel | APITicketPanel[]): TicketPanel | Collection<string, TicketPanel>;
+    toJSON(): APITicketPanel[];
+}
+
+declare class TicketPanel implements APITicketPanel {
+    #private;
+    _id: string;
+    guild_id: string;
+    name: string;
+    categories: APITicketCategory[];
+    components_type: "button" | "stringselect";
+    createdAt: Date;
+    message: {
+        embeds: APIEmbed[];
+    };
+    updatedAt: Date;
+    readonly rest: REST;
+    readonly guild: Guild;
+    readonly data: APITicketPanel;
+    readonly manager: TicketPanelManager;
+    constructor(data: APITicketPanel, manager: TicketPanelManager);
+    addCategory(data: Optional<APITicketCategory>): Promise<APITicketCategory>;
+    deleteCategory(id: string): Promise<this>;
+    updateCategory(id: string, data: Optional<APITicketCategory>): Promise<this>;
+    addRoleIdToCategory(id: string, ...roles: string[]): Promise<this>;
+    setRoleIdsToCategory(id: string, ...roles: string[]): Promise<this>;
+    removeRoleIdToCategory(id: string, ...roles: string[]): Promise<this>;
+    update(data: Optional<APITicketPanel>): Promise<this>;
+    delete(): Promise<APITicketPanel>;
+    toJSON(): APITicketPanel;
+}
+
+interface FetchOptions$6 {
+    cache?: boolean;
+    tournamentId?: string;
+}
+type ReturnFetchOptions$5<T extends FetchOptions$6> = T["cache"] extends true ? Collection<string, Tournament> : T["tournamentId"] extends string ? Tournament : Collection<string, Tournament>;
+declare class TournamentManager extends BaseManager<Tournament> {
+    constructor(guild: Guild);
+    fetch<T extends FetchOptions$6>(options?: T): Promise<ReturnFetchOptions$5<T>>;
+    set(data: APITournament | APITournament[]): Collection<string, Tournament>;
+    _add(data: APITournament | APITournament[]): Tournament | Collection<string, Tournament>;
+    create(data: Optional<APITournament>): Promise<Tournament>;
+}
+
+declare class Tournament {
+    #private;
+    _id: string;
+    guild_id: string;
+    type: "1v1" | "2v2" | "3v3" | "4v4";
+    max_teams: number;
+    teams: APIPlayer[][];
+    logs_url: {
+        cancelled: string;
+        started: string;
+        finished: string;
+    };
+    message: any;
+    message_id: string;
+    status: "created" | "on" | "off";
+    createdAt: Date;
+    updatedAt: Date;
+    readonly guild: Guild;
+    readonly rest: REST;
+    readonly manager: TournamentManager;
+    readonly data: APITournament;
+    constructor(data: APITournament, manager: TournamentManager);
+    fetch(): Promise<this>;
+    update(data: Optional<APITournament>): Promise<this>;
+    toJSON(): {
+        guild_id: string;
+        type: "1v1" | "2v2" | "3v3" | "4v4";
+        max_teams: number;
+        teams: APIPlayer[][];
+        message: any;
+        message_id: string;
+        status: "on" | "off" | "created";
+        createdAt: Date;
+        updatedAt: Date;
+    };
+}
+
 type FecthOptions$1 = {
     cache?: boolean;
     memberId?: string;
@@ -1007,7 +1238,7 @@ declare class VipMember implements APIVipMember {
     toJSON(): Record<keyof APIVipMember, unknown>;
 }
 
-declare class GuildTicket implements APIGuildTicket {
+declare class GuildTicket {
     #private;
     _id: string;
     guild_id: string;
@@ -1018,7 +1249,7 @@ declare class GuildTicket implements APIGuildTicket {
     closed_by_id: string;
     creator_id: string;
     customer_rating: number;
-    messages: APIMessage[];
+    messages: MessagesManager<GuildTicket>;
     createdAt: Date;
     updatedAt: Date;
     readonly rest: REST;
@@ -1026,15 +1257,15 @@ declare class GuildTicket implements APIGuildTicket {
     readonly manager: GuildTicketManager;
     constructor(data: APIGuildTicket, manager: any);
     fetch(): Promise<GuildTicket>;
+    delete(): Promise<APIGuildTicket>;
     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<APIMessage>): Promise<GuildTicket>;
 }
 
-interface FetchOptions$4 {
+interface FetchOptions$5 {
     cache?: boolean;
     gameId?: string;
 }
@@ -1044,7 +1275,7 @@ declare class MinesGameManager {
     constructor(rest: REST);
     create(data: Optional<APIMinesGame>): Promise<MinesGame>;
     delete(gameId: string): Promise<unknown>;
-    fetch(options?: FetchOptions$4): Promise<MinesGame | Collection<string, MinesGame>>;
+    fetch(options?: FetchOptions$5): Promise<MinesGame | Collection<string, MinesGame>>;
     set(data: APIMinesGame | APIMinesGame[]): MinesGame | Collection<string, MinesGame>;
 }
 
@@ -1069,48 +1300,72 @@ declare class MinesGame {
     update(data: Optional<APIMinesGame>): Promise<this>;
 }
 
-declare class Tournament {
+type FetchOptions$4 = {
+    cache?: boolean;
+    productId?: string;
+};
+type ReturnFetchOptions$4<T extends FetchOptions$4> = T["cache"] extends true ? Collection<string, Product> : T["productId"] extends string ? Product : Collection<string, Product>;
+declare class ProductManager extends BaseManager<Product> {
+    shop: Shop;
+    constructor(shop: Shop);
+    fetch<T extends FetchOptions$4>(options?: T): Promise<ReturnFetchOptions$4<T>>;
+    create(data: Optional<APIProduct>): Promise<Product>;
+    delete(id: string): Promise<Shop>;
+    set(data: APIProduct | APIProduct[]): Product | Collection<string, Product>;
+    toJSON(): APIProduct[];
+}
+
+declare class Shop {
     #private;
     _id: string;
+    name: string;
     guild_id: string;
-    type: string;
-    max_teams: number;
-    teams: APIPlayer[][];
-    message: any;
-    message_id: string;
-    status: "created" | "on" | "off";
+    embeds: APIEmbed[];
+    /** Shop's products */
+    products: ProductManager;
+    /** Bought count */
+    bought_count: number;
+    /** Creation Date */
     createdAt: Date;
+    /** Updated Date */
     updatedAt: Date;
-    readonly guild: Guild;
+    readonly manager: ShopManager;
     readonly rest: REST;
-    readonly manager: TournamentManager;
-    readonly data: APITournament;
-    constructor(data: APITournament, manager: TournamentManager);
+    readonly guild: Guild;
+    constructor(data: APIGuildShop, manager: ShopManager);
     fetch(): Promise<this>;
-    update(data: Optional<APITournament>): Promise<this>;
-    toJSON(): {
-        guild_id: string;
-        type: string;
-        max_teams: number;
-        teams: APIPlayer[][];
-        message: any;
-        message_id: string;
-        status: "on" | "off" | "created";
-        createdAt: Date;
-        updatedAt: Date;
-    };
+    delete(): Promise<void>;
+    update(data: Optional<APIGuildShop>): Promise<this>;
+    toJSON(): Optional<APIGuildShop>;
 }
 
-interface FetchOptions$3 {
-    cache?: boolean;
-    tournamentId?: string;
-}
-type ReturnFetchOptions$3<T extends FetchOptions$3> = T["cache"] extends true ? Collection<string, Tournament> : T["tournamentId"] extends string ? Tournament : Collection<string, Tournament>;
-declare class TournamentManager extends BaseManager<Tournament> {
-    constructor(guild: Guild);
-    fetch<T extends FetchOptions$3>(options?: T): Promise<ReturnFetchOptions$3<T>>;
-    set(data: APITournament | APITournament[]): Collection<string, Tournament>;
-    _add(data: APITournament | APITournament[]): Collection<string, Tournament>;
+declare class Product implements APIProduct {
+    #private;
+    /** Product's name */
+    name: string;
+    /** Product's description */
+    description: string;
+    /** Product's id */
+    _id: string;
+    /** Product's price */
+    price: number;
+    /** Product's buyers */
+    buyers: APIPlayer[];
+    /** Product's emoji */
+    emoji: string;
+    units_in_stock: number;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    readonly shop: Shop;
+    readonly manager: ProductManager;
+    readonly data: APIProduct;
+    constructor(data: APIProduct, manager: ProductManager);
+    fetch(): Promise<Product>;
+    update(data: Optional<APIProduct>): Promise<this>;
+    delete(): Promise<Shop>;
+    toJSON(): APIProduct;
 }
 
 declare class Guild {
@@ -1132,6 +1387,8 @@ declare class Guild {
     tickets_configuration: GuildTicketConfiguration;
     /** Guild Daily Categories */
     daily_categories: DailyCategories[];
+    match_count: number;
+    bet_count: number;
     /** Guild Scores */
     scores: GuildScores;
     /** Guild Status */
@@ -1154,14 +1411,15 @@ declare class Guild {
     vipMembers: VipMemberManager;
     users: GuildUserManager;
     logEntries: LogManager;
-    shop: APIGuildShop;
+    shops: ShopManager;
     betusers: GuildBetUserManager;
     bets: GuildBetManager;
     mediators: GuildMediatorManager;
-    automatic_messages: APIAutomaticMessage[];
-    automaticMessagesManager: AutomaticMessageManager;
+    automaticMessages: AutomaticMessageManager;
     tournaments: TournamentManager;
+    webhook_urls: GuildLogsWebhookUrls;
     adverts: APIGuildAdvert[];
+    ticket_panels: TicketPanelManager;
     codes: APICode[];
     coin_symbol: string;
     /**
@@ -1170,9 +1428,11 @@ declare class Guild {
      * @param rest The rest client
      */
     constructor(data: APIGuild, rest: REST);
+    _start(): Promise<this>;
     getChannel(type: GuildChannelsType): Promise<APIGuildGroupedChannel>;
     getPermission(type: GuildPermissionsTypes): Promise<Permission>;
     createAdvert(data: Optional<APIGuildAdvert>): Promise<this>;
+    updateAdvert(data: Optional<APIGuildAdvert>): Promise<this>;
     removeAdvert(advertId: string): Promise<this>;
     createCode(data: Optional<APICode>): Promise<this>;
     removeCode(codeId: string): Promise<this>;
@@ -1182,10 +1442,10 @@ declare class Guild {
     updateRouletteSettings(data: Optional<RouletteSettings> & {
         default?: boolean;
     }): Promise<Guild>;
+    updateLogWebhookUrls(data: Optional<GuildLogsWebhookUrls>): Promise<Guild>;
     getActive(key: "matches" | "tickets" | "bets"): Collection<string, GuildTicket> | Collection<string, GuildMatch> | Collection<string, GuildBet>;
     addRoulettePrize(prize: Optional<RoulettePrize>): Promise<RoulettePrize>;
     removeRoulettePrize(id: string): Promise<Guild>;
-    _start(): Promise<this>;
     fetch(): Promise<Guild>;
     reset(): Promise<Guild>;
     update(data: Optional<APIGuild> & {
@@ -1194,18 +1454,19 @@ declare class Guild {
     setStatus(key: keyof GuildStatus, status: "on" | "off"): Promise<this>;
     togglePrice(price: number): Promise<this>;
     addPrefix(prefixes: string | string[]): Promise<this>;
-    setPrefix(prefixes: string | string[]): Promise<this>;
+    removePrefix(prefixes: string | string[]): Promise<this>;
+    setPrefixes(prefixes: string | string[]): Promise<this>;
     toggleDailyCategory(category: keyof Omit<Daily, "date">): Promise<this>;
     setScores(name: AvailableScores, amount: number): Promise<this>;
     toggleMode(mode: "1v1" | "2v2" | "3v3" | "4v4" | "5v5" | "6v6"): Promise<this>;
 }
 type AvailableScores = "win" | "loss" | "mvp" | "creator" | "coin";
 
-type FetchOptions$2 = {
+type FetchOptions$3 = {
     guildId?: string;
     cache?: boolean;
 };
-type ReturnFetchOptions$2<T extends FetchOptions$2> = T["cache"] extends true ? Collection<string, Guild> : T["guildId"] extends string ? Guild : Collection<string, Guild>;
+type ReturnFetchOptions$3<T extends FetchOptions$3> = T["cache"] extends true ? Collection<string, Guild> : T["guildId"] extends string ? Guild : Collection<string, Guild>;
 type DeleteOptions$1 = {
     guildId?: string;
 };
@@ -1225,7 +1486,7 @@ declare class GuildManager {
      * @param id Id of the guild to fetch
      * @returns APIGuild
      */
-    fetch<T extends FetchOptions$2>(options?: T): Promise<ReturnFetchOptions$2<T>>;
+    fetch<T extends FetchOptions$3>(options?: T): Promise<ReturnFetchOptions$3<T>>;
     reset(guildId?: string): Promise<Guild | Collection<string, Guild>>;
     delete(options: DeleteOptions$1): Promise<Collection<string, Guild> | boolean>;
     set(data: APIGuild | APIGuild[]): Guild | Collection<string, Guild>;
@@ -1269,7 +1530,7 @@ declare class REST extends EventEmitter {
      * @param options
      * @returns
      */
-    request<Expecting, Payload>(options: RequestOptions<Payload>): Promise<Expecting>;
+    request<Expecting, Payload extends object>(options: RequestOptions<Payload>): Promise<Expecting>;
     getStatus(): Promise<StatusResponse>;
     emit<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]): boolean;
     on<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void): this;
@@ -1286,54 +1547,28 @@ declare class BaseManager<S extends object> {
     /** Cache */
     cache: Collection<string, S>;
     constructor(guild: Guild);
-    toJSON(): S[];
-}
-
-declare class AutomaticMessage {
-    #private;
-    id: string;
-    type: AutomaticMessagesTypes;
-    admin_id: string;
-    channel_ids: string[];
-    content: string;
-    embeds: any[];
-    components: any[];
-    attachments: any[];
-    flags: number;
-    interval_ms: number;
-    createdAt: Date;
-    updatedAt: Date;
-    readonly guild: Guild;
-    readonly manager: AutomaticMessageManager;
-    readonly rest: REST;
-    constructor(data: APIAutomaticMessage, manager: AutomaticMessageManager);
-    fetch(): Promise<Collection<string, AutomaticMessage>>;
-    addChannelId(...id: string[]): Promise<this>;
-    removeChannelId(...id: string[]): Promise<this>;
-    update(data: Optional<APIAutomaticMessage>): Promise<this>;
-    delete(): Promise<Collection<string, APIAutomaticMessage>>;
-    toJSON(): APIAutomaticMessage;
+    toJSON(): S[] | any;
 }
 
 declare class AutomaticMessageManager extends BaseManager<AutomaticMessage> {
     constructor(guild: Guild);
-    fetch<T extends string>(messageId?: T): Promise<Collection<string, AutomaticMessage>>;
+    fetch<T extends string>(messageId?: T): Promise<T extends true ? AutomaticMessage : Collection<string, AutomaticMessage>>;
     create(data: Optional<APIAutomaticMessage>): Promise<AutomaticMessage>;
-    _add(data: APIAutomaticMessage | APIAutomaticMessage[]): Collection<string, AutomaticMessage>;
+    _add(data: APIAutomaticMessage | APIAutomaticMessage[]): AutomaticMessage | Collection<string, AutomaticMessage>;
     set(data: APIAutomaticMessage | APIAutomaticMessage[]): Collection<string, APIAutomaticMessage>;
-    delete(messageId?: string): Promise<APIGuild | Collection<string, APIAutomaticMessage>>;
-    toJSON(): AutomaticMessage[];
+    delete(messageId?: string): Promise<boolean | APIGuild>;
+    toJSON(): APIAutomaticMessage[];
 }
 
-interface FetchOptions$1 {
+interface FetchOptions$2 {
     cache?: boolean;
     betId?: string;
 }
-type ReturnFetchOptions$1<T extends FetchOptions$1> = T["cache"] extends true ? Collection<string, GuildBet> : T["betId"] extends string ? GuildBet : Collection<string, GuildBet>;
+type ReturnFetchOptions$2<T extends FetchOptions$2> = T["cache"] extends true ? Collection<string, GuildBet> : T["betId"] extends string ? GuildBet : Collection<string, GuildBet>;
 declare class GuildBetManager extends BaseManager<GuildBet> {
     constructor(guild: Guild);
     toString(): number;
-    fetch<T extends FetchOptions$1>(options?: T): Promise<ReturnFetchOptions$1<T>>;
+    fetch<T extends FetchOptions$2>(options?: T): Promise<ReturnFetchOptions$2<T>>;
     create(data: Optional<APIGuildBet>): Promise<GuildBet>;
     delete(betId?: string): Promise<GuildBet>;
     set(data: Optional<APIGuildBet> | Optional<APIGuildBet>[] | GuildBet): GuildBet;
@@ -1362,11 +1597,11 @@ declare class LogManager extends BaseManager<LogEntry> {
     set(data: APILogEntry | APILogEntry[]): LogEntry | Collection<string, LogEntry>;
 }
 
-type FetchOptions = {
-    cache: boolean;
-    matchId: string;
+type FetchOptions$1 = {
+    cache?: boolean;
+    matchId?: string;
 };
-type ReturnFetchOptions<T extends FetchOptions> = T["cache"] extends true ? Collection<string, GuildMatch> : T["matchId"] extends string ? GuildMatch : Collection<string, GuildMatch>;
+type ReturnFetchOptions$1<T extends FetchOptions$1> = T["cache"] extends true ? Collection<string, GuildMatch> : T["matchId"] extends string ? GuildMatch : Collection<string, GuildMatch>;
 declare class GuildMatchManager extends BaseManager<GuildMatch> {
     /**
      * Manage users with the given client
@@ -1379,8 +1614,7 @@ declare class GuildMatchManager extends BaseManager<GuildMatch> {
      * @param id Id of the match to fetch
      * @returns APIBetUser
      */
-    fetch<T extends FetchOptions>(options?: T): Promise<ReturnFetchOptions<T>>;
-    fetchAll(): Promise<Collection<string, GuildMatch>>;
+    fetch<T extends FetchOptions$1>(options?: T): Promise<ReturnFetchOptions$1<T>>;
     set(data: APIGuildMatch | APIGuildMatch[] | GuildMatch): GuildMatch | Collection<string, GuildMatch>;
     create(payload: Optional<APIGuildMatch>): Promise<GuildMatch>;
     delete(id?: string): Promise<GuildMatch | Collection<string, GuildMatch>>;
@@ -1404,10 +1638,25 @@ declare class MessagesManager<Structure> {
 
 declare class GuildPermissionManager extends BaseManager<APIGuildPermissions> {
     constructor(guild: Guild);
+    setRoleIds(type: GuildPermissionsTypes, ...ids: string[]): Promise<APIGuild>;
     addRole(type: GuildPermissionsTypes, ...ids: string[]): Promise<APIGuild>;
     removeRole(type: GuildPermissionsTypes, ...ids: string[]): Promise<APIGuild>;
 }
 
+type FetchOptions = {
+    cache?: boolean;
+    shopId?: string;
+};
+type ReturnFetchOptions<T extends FetchOptions> = T["cache"] extends true ? Collection<string, Shop> : T["shopId"] extends string ? Shop : Collection<string, Shop>;
+declare class ShopManager extends BaseManager<Shop> {
+    constructor(guild: Guild);
+    fetch<T extends FetchOptions>(options?: T): Promise<ReturnFetchOptions<T>>;
+    create(data: Optional<APIGuildShop>): Promise<Shop>;
+    delete(id: string): Promise<Collection<string, Shop>>;
+    set(data: APIGuildShop | APIGuildShop[] | Shop): Shop | Collection<string, Shop>;
+    toJSON(): Shop[];
+}
+
 type FecthOptions = {
     ticketId?: string;
     cache?: boolean;
@@ -1425,7 +1674,7 @@ declare class GuildTicketManager {
     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>;
+    set(data: APIGuildTicket | GuildTicket | APIGuildTicket[]): GuildTicket | Collection<string, GuildTicket>;
 }
 
-export { type GuildPrices as $, AutomaticMessageManager as A, type BufferMatch as B, type OriginalChannels as C, type Accessory as D, type Daily as E, type FetchOptions$1 as F, GuildBetManager as G, type Banner as H, type Confirm as I, type Optional as J, MATCHTYPES as K, LogManager as L, MessagesManager as M, MATCHSTATUS as N, type OriginalChannel as O, type ProfileCard as P, BETSTATUS as Q, REST as R, STATES as S, type StatusResponse as T, type APIAutomaticMessage as U, VipMemberManager as V, type GuildTicketConfiguration as W, type GuildStatus as X, GuildStatusEnum as Y, type GuildModes as Z, type DailyCategories as _, GuildBetUserManager as a, type GuildScores as a0, type RoulettePrize as a1, type RouletteSettings as a2, AutomaticMessagesTypes as a3, GuildChannelsType as a4, type APIGuild as a5, type BetQueue as a6, BetChannelTypes as a7, type APIGuildBet as a8, type APIGuildBetUser as a9, type APIGuildGroupedChannel as aa, type MatchSelection as ab, type APIGuildMatch as ac, GuildMatchChannelsType as ad, GuildMatchMessagesType as ae, type Profile as af, type APIGuildUser as ag, type RequestOptions as ah, type RestEvents as ai, type PlayerOption as aj, type Structure as ak, PlayerManager as al, Tournament as am, TournamentManager as an, AutomaticMessage as ao, type BufferTicket as b, BufferManager as c, GuildManager as d, GuildMatchManager as e, GuildMediatorManager as f, MinesGameManager as g, GuildPermissionManager as h, GuildTicketManager as i, GuildUserManager as j, BaseManager as k, GuildBet as l, GuildBetUser as m, Guild as n, LogEntry as o, GuildMatch as p, GuildMediator as q, GuildUser as r, VipMember as s, GuildTicket as t, MinesGame as u, type APITicketCategory as v, type LogMessage as w, type BaseMatchModes as x, type BaseMatchStatus as y, type Logs as z };
+export { GuildUserManager as $, type APIAutomaticMessage as A, BETSTATUS as B, type Confirm as C, type Daily as D, GuildBetUserManager as E, type FetchOptions$2 as F, Guild as G, GuildChannelsType as H, type GuildLogsWebhookUrls as I, GuildManager as J, GuildMatch as K, GuildMatchChannelsType as L, GuildMatchManager as M, GuildMatchMessagesType as N, GuildMediator as O, GuildMediatorManager as P, type GuildModes as Q, REST as R, GuildPermissionManager as S, type GuildPrices as T, type GuildScores as U, type GuildStatus as V, GuildStatusEnum as W, GuildTicket as X, type GuildTicketConfiguration as Y, GuildTicketManager as Z, GuildUser as _, type APIGuild as a, LogEntry as a0, LogManager as a1, type LogMessage as a2, type Logs as a3, MATCHSTATUS as a4, MATCHTYPES as a5, type MatchSelection as a6, MessagesManager as a7, MinesGame as a8, MinesGameManager as a9, type Optional as aa, type OriginalChannel as ab, type OriginalChannels as ac, PlayerManager as ad, type PlayerOption as ae, Product as af, type Profile as ag, type ProfileCard as ah, type RequestOptions as ai, type RestEvents as aj, type RoulettePrize as ak, type RouletteSettings as al, STATES as am, Shop as an, ShopManager as ao, type StatusResponse as ap, type Structure as aq, TicketPanel as ar, TicketPanelManager as as, Tournament as at, TournamentManager as au, UserAccessoryType as av, VipMember as aw, VipMemberManager as ax, ProductManager as ay, type APIGuildBet as b, type APIGuildBetUser as c, type APIGuildGroupedChannel as d, type APIGuildMatch as e, type APIGuildUser as f, type APITicketCategory as g, type APITicketPanel as h, type Accessory as i, AutomaticMessage as j, AutomaticMessageManager as k, AutomaticMessagesTypes as l, type Banner as m, BaseManager as n, type BaseMatchModes as o, type BaseMatchStatus as p, BetChannelTypes as q, type BetQueue as r, BufferManager as s, type BufferMatch as t, type BufferTicket as u, type DailyCategories as v, type FetchReturn as w, GuildBet as x, GuildBetManager as y, GuildBetUser as z };