@duque.edits/sdk 1.1.2 → 1.3.0

package/dist/{index-BPxglVSk.d.ts → index-0BFrnm6S.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",
@@ -317,6 +352,10 @@ interface Profile {
     textColor?: string;
     primaryColor?: string;
     secondaryColor?: string;
+    booster: {
+        status: "on" | "off";
+        expires: number;
+    };
 }
 interface APIGuildUser {
     /** User's id */
@@ -330,9 +369,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 +385,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 +416,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 +452,22 @@ 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: UserAcessoryType;
+    units: number;
+    time: number;
+};
+type ActiveAccessories = {
+    type: UserAcessoryType;
+    double_points: Accessory[];
+    losses_protection: Accessory[];
+    points_protection: Accessory[];
 };
+declare enum UserAcessoryType {
+    PointsProtection = "points_protection",
+    LossesProtection = "losses_protection",
+    DoublePoints = "double_points",
+    Active = "active"
+}
 /** Daily information */
 type Daily = {
     /** Wins */
@@ -489,14 +552,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 +594,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 +635,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 +746,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,20 +789,21 @@ 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>>;
     set(data: APIGuildUser | APIGuildUser[]): GuildUser | Collection<string, GuildUser>;
 }
 
+type AccReturn<T extends UserAcessoryType> = T extends UserAcessoryType.Active ? string : number;
 declare class GuildUser implements APIGuildUser {
     #private;
     /** User's id */
@@ -685,6 +832,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 +864,18 @@ 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 UserAcessoryType>(type: T): Promise<Accessory>;
+    addAccessory<T extends UserAcessoryType>(type: T, data: {
+        units: number;
+        time: number;
+    }): Promise<this>;
+    removeAccessory<T extends UserAcessoryType>(type: T, data: {
+        units: number;
+        time: number;
+    }): Promise<this>;
     addAdvert(data: Optional<Omit<APIAdvert, "_id">>): Promise<GuildUser>;
     removeAdvert(advertId?: string): Promise<GuildUser>;
     /**
@@ -722,11 +883,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 +934,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 +994,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 +1071,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 +1235,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 +1246,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;
@@ -1031,10 +1259,9 @@ declare class GuildTicket implements APIGuildTicket {
     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 +1271,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 +1296,71 @@ 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;
+    /** 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 +1382,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 +1406,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 +1423,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 +1437,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 +1449,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 +1481,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 +1525,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 +1542,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 +1592,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 +1609,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 +1633,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 +1669,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 { GuildTicketManager as $, type APIAutomaticMessage as A, BETSTATUS as B, type Confirm as C, type Daily as D, GuildBetManager as E, type FetchOptions$2 as F, Guild as G, GuildBetUser as H, GuildBetUserManager as I, GuildChannelsType as J, type GuildLogsWebhookUrls as K, GuildManager as L, GuildMatch as M, GuildMatchChannelsType as N, GuildMatchManager as O, GuildMatchMessagesType as P, GuildMediator as Q, REST as R, GuildMediatorManager as S, type GuildModes as T, GuildPermissionManager as U, type GuildPrices as V, type GuildScores as W, type GuildStatus as X, GuildStatusEnum as Y, GuildTicket as Z, type GuildTicketConfiguration as _, type APIGuild as a, GuildUser as a0, GuildUserManager as a1, LogEntry as a2, LogManager as a3, type LogMessage as a4, type Logs as a5, MATCHSTATUS as a6, MATCHTYPES as a7, type MatchSelection as a8, MessagesManager as a9, ProductManager as aA, MinesGame as aa, MinesGameManager as ab, type Optional as ac, type OriginalChannel as ad, type OriginalChannels as ae, PlayerManager as af, type PlayerOption as ag, Product as ah, type Profile as ai, type ProfileCard as aj, type RequestOptions as ak, type RestEvents as al, type RoulettePrize as am, type RouletteSettings as an, STATES as ao, Shop as ap, ShopManager as aq, type StatusResponse as ar, type Structure as as, TicketPanel as at, TicketPanelManager as au, Tournament as av, TournamentManager as aw, UserAcessoryType as ax, VipMember as ay, VipMemberManager as az, 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 AccReturn as i, type Accessory as j, type ActiveAccessories as k, AutomaticMessage as l, AutomaticMessageManager as m, AutomaticMessagesTypes as n, type Banner as o, BaseManager as p, type BaseMatchModes as q, type BaseMatchStatus as r, BetChannelTypes as s, type BetQueue as t, BufferManager as u, type BufferMatch as v, type BufferTicket as w, type DailyCategories as x, type FetchReturn as y, GuildBet as z };