@duque.edits/sdk 1.0.87 → 1.1.2

package/dist/index-BPxglVSk.d.ts

@@ -0,0 +1,1431 @@
+import { APIAdvert } from './types/api/APIAdvert.js';
+import { APIBaseChannel } from './types/api/APIBaseChannel.js';
+import { APIBetChannel } from './types/api/APIBetChannel.js';
+import { APICode } from './types/api/APICode.js';
+import './types/api/APIGiveaway.js';
+import { APIGuildAdvert } from './types/api/APIGuildAdvert.js';
+import './types/api/APIGuildChannel.js';
+import { APIGuildMediator } from './types/api/APIGuildMediator.js';
+import { APIGuildPermissions, GuildPermissionsTypes, Permission } from './types/api/APIGuildPermissions.js';
+import { APIGuildShop } from './types/api/APIGuildShop.js';
+import { APIGuildTicket } from './types/api/APIGuildTicket.js';
+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 { APIVipMember } from './types/api/APIVipMember.js';
+import { Collection } from './structures/Collection.js';
+import EventEmitter from 'events';
+import { APITournament } from './types/api/APITournament.js';
+
+interface APIGuildGroupedChannel {
+    /** Channel's type */
+    type: string & GuildChannelsType;
+    /** Channel's ids */
+    ids: string[];
+}
+
+/** Ticket's configuration */
+interface GuildTicketConfiguration {
+    /** Guild's categories */
+    categories: APITicketCategory[];
+    creationCategory: string;
+    deletionCategory: string;
+    rating_channel_id: string;
+}
+interface GuildStatus {
+    /** Matches status */
+    matches: "on" | "off";
+    /** Bets status */
+    bets: "on" | "off";
+    /** Daily Ranking status */
+    daily_rank: "on" | "off";
+    /** Voice Channels for a bet */
+    create_voice_channels: "on" | "off";
+    two_mvps: "on" | "off";
+    ranking_name: "on" | "off";
+    logs_queues: "on" | "off";
+    logs_users: "on" | "off";
+    logs_managing: "on" | "off";
+    name_hidden: "on" | "off";
+}
+declare enum GuildStatusEnum {
+    /** Matches status */
+    Matches = "matches",
+    /** Bets status */
+    Bets = "bets",
+    /** Daily Ranking status */
+    DailyRank = "daily_rank",
+    /** Voice Channels for a bet */
+    CreateVoiceChannels = "create_voice_channels",
+    TwoMvps = "two_mvps",
+    RankingName = "ranking_name",
+    LogsQueues = "logs_queues",
+    LogsUsers = "logs_users",
+    LogsManaging = "logs_managing",
+    NameHidden = "name_hidden"
+}
+interface GuildModes {
+    on: string[];
+    off: string[];
+}
+type DailyCategories = "coins" | "credit" | "wins" | "points" | "losses" | "mvps";
+type GuildPrices = number[];
+interface GuildScores {
+    /** Win */
+    win: number;
+    /** Loss */
+    loss: number;
+    /** Mvp */
+    mvp: number;
+    /** Coin */
+    coin: number;
+    /** Creator */
+    creator: number;
+}
+interface RoulettePrize {
+    label: string;
+    custom_color: string;
+    custom_probability: number;
+    _id: string;
+}
+interface RouletteSettings {
+    primary_color: string;
+    secondary_color: string;
+    tertiary_color: string;
+    text_color: string;
+    prizes: RoulettePrize[];
+}
+declare enum AutomaticMessagesTypes {
+    MatchStarted = "match_started",
+    Miscellaneous = "miscellaneous"
+}
+declare enum GuildChannelsType {
+    DailyRank = "daily_rank",
+    Commands = "command",
+    Blacklist = "blacklist",
+    Queues = "queue",
+    VipMemebers = "vipmembers_category",
+    QueueLogs = "queue_logs",
+    UserLogs = "user_logs",
+    TicketLogs = "ticket_logs",
+    ManagingLogs = "managing_logs",
+    NormalQueue = "normal_queue",
+    ChallengeQueue = "challenge_queue",
+    MatchTextChannelParent = "match_text_channel_parent",
+    VoiceChannelMatchCreation = "voice_channel_match_creation",
+    WaitingVC = "waiting_vc",
+    BetMobileCategory = "bet_mobile_category",
+    BetEmulatorCategory = "bet_emulator_category",
+    BetMixCategory = "bet_mix_category",
+    RouletteLogs = "roulette_logs",
+    Rules = "rules"
+}
+interface APIGuild {
+    /** Guild's id */
+    id: string;
+    /** Guild's client key */
+    client_key: string;
+    modes: GuildModes;
+    /** Guild Permissions */
+    permissions: APIGuildPermissions;
+    /** Guild Ticket Configuration */
+    tickets_configuration: GuildTicketConfiguration;
+    /** Guild Daily Categories */
+    daily_categories: DailyCategories[];
+    /** Guild Scores */
+    scores: GuildScores;
+    /** Guild Status */
+    status: GuildStatus;
+    /** Guild Channel */
+    channels: APIGuildGroupedChannel[];
+    /** Guild Categories */
+    categories: APIGuildGroupedChannel[];
+    /** Guild Prefix */
+    prefix: string;
+    prefixes: string[];
+    /** Guild Prices Used */
+    prices: GuildPrices;
+    /** Guild Creation Date */
+    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;
+    autorole_config: {
+        role: string;
+    };
+    automatic_messages: APIAutomaticMessage[];
+}
+
+interface APIAutomaticMessage {
+    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;
+}
+
+interface BetQueue {
+    _id: string;
+    type: string;
+    players: APIPlayer[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare enum BetChannelTypes {
+    CreationChannel = "creation_channel"
+}
+interface APIGuildBet {
+    /** 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;
+    guild_id: string;
+    /** The bet's players */
+    players: APIPlayer[];
+    teams: APIPlayer[][];
+    /** The bet's channel */
+    channels: APIBetChannel[];
+    /** The bet's messages */
+    messages: APIMessage[];
+    /** 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[];
+}
+
+/** Bet user */
+interface APIGuildBetUser {
+    /** User daily */
+    daily: Omit<Daily, "points">;
+    profile: Profile;
+    consecutive_wins: number;
+    /** User's name */
+    id: string;
+    guild_id: string;
+    /** User's credit */
+    credit: number;
+    /** User's wins */
+    wins: number;
+    /** User's losses */
+    losses: number;
+    /** User's games */
+    games: number;
+    /** User's blacklist */
+    blacklist: boolean;
+    /** User's coins */
+    coins: number;
+    spins: number;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+}
+
+type MatchSelection = {
+    type: "creator" | "mvps" | "winners";
+    selected: string[];
+    confirmed: string[];
+};
+interface APIGuildMatch {
+    selections: MatchSelection[];
+    /** Match's type */
+    type: BaseMatchModes;
+    guild_id: string;
+    /** Match's status */
+    status: BaseMatchStatus;
+    /** Match's challenge */
+    challenge: boolean;
+    admin_id: string;
+    /** Match's players */
+    players: APIPlayer[];
+    /** Match's winners */
+    winners: APIPlayer[];
+    /** Match's losers */
+    losers: APIPlayer[];
+    /** Match;s messages */
+    messages: APIMessage[];
+    /** Matches channels */
+    channels: APIBaseChannel[];
+    /** Match's maximum size */
+    maximumSize: number;
+    /** Match's kicked out */
+    kickedOut: APIPlayer[];
+    /** Match's confirmed */
+    confirmed: Confirm[];
+    /** Match's leaders */
+    leaders: APIPlayer[];
+    teams: APIPlayer[][];
+    creatorId: string;
+    /** Match's room creator id */
+    roomCreatorId: string;
+    bet: APIGuildBet | GuildBet;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** Match's id */
+    _id: string;
+    mvps: [];
+}
+declare enum GuildMatchChannelsType {
+    CreationChannel = "creation_channel",
+    TextChannel = "text_channel"
+}
+declare enum GuildMatchMessagesType {
+    CreationMessage = "creation_message"
+}
+
+interface Profile {
+    bannerUrl?: string;
+    avatarUrl?: string;
+    bio?: string;
+    name?: string;
+    textColor?: string;
+    primaryColor?: string;
+    secondaryColor?: string;
+}
+interface APIGuildUser {
+    /** User's id */
+    id: string;
+    guild_id: string;
+    /** User's daily */
+    daily: Omit<Daily, "credit">;
+    profile: Profile;
+    /** User's points */
+    points: number;
+    creations: number;
+    /** User's wins */
+    wins: number;
+    adverts: APIAdvert[];
+    /** User's mvps */
+    mvps: number;
+    /** User's losses */
+    losses: number;
+    /** User's games */
+    games: number;
+    /** If user is blacklisted */
+    blacklist: boolean;
+    /** User's accessories such as double point */
+    accessories: Accessory[];
+    /** User's original channels */
+    original_channels: OriginalChannels;
+    spins: number;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+}
+
+interface APITicketCategory {
+    /** Category's type */
+    type: string;
+    /** Category's emoji */
+    emoji: string;
+    /** Category's description */
+    description: string;
+    /** Category's alias */
+    alias: string;
+}
+interface LogMessage {
+    /** The message's content */
+    content: string | Buffer<any>;
+    /** The message's sender */
+    userId: string;
+    /** The message's type */
+    type: string;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+}
+/** Base match modes */
+type BaseMatchModes = "1v1" | "2v2" | "3v3" | "4v4" | "5v5" | "6v6";
+/** Base match status */
+type BaseMatchStatus = "on" | "created" | "off" | "shutted";
+/** The logs of the structure */
+interface Logs {
+    /** The messages of the structure */
+    messages: LogMessage[];
+}
+/** Original Channel */
+type OriginalChannel = {
+    /** Channel id */
+    channelId: string;
+    /** Match id */
+    matchId: string;
+};
+/** Original Channels */
+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;
+};
+/** Daily information */
+type Daily = {
+    /** Wins */
+    wins: number;
+    /** Coins */
+    coins: number;
+    /** Points */
+    points: number;
+    /** Credit */
+    credit: number;
+    /** Losses */
+    losses: number;
+    /** Mvps */
+    mvps: number;
+    /** Date of the daily */
+    date: Date;
+};
+interface Banner {
+    /** Equipped banner */
+    equipped: number;
+    /** Bought banners */
+    allowed: number[];
+}
+interface ProfileCard {
+    /** Profile's description */
+    description: string;
+    /** Profile's banner */
+    banner: Banner;
+}
+interface Confirm {
+    /** Confirm's type */
+    type: string;
+    /** Confirm's id */
+    ids: string[];
+    /** Confirm's counts */
+    count: number;
+}
+type Optional<T> = {
+    [K in keyof T]?: T[K];
+};
+declare enum MATCHTYPES {
+    OneVOne = "1v1",
+    TwoVTwo = "2v2",
+    ThreeVThree = "3v3",
+    FourVFour = "4v4",
+    FiveVFive = "5v5",
+    SixVSix = "6v6"
+}
+declare enum MATCHSTATUS {
+    ON = "on",
+    OFF = "off",
+    CREATED = "created",
+    SHUTTED = "shutted"
+}
+declare enum BETSTATUS {
+    ON = "on",
+    OFF = "off",
+    CREATED = "created",
+    SHUTTED = "shutted",
+    WAITING = "waiting"
+}
+declare enum STATES {
+    ON = "on",
+    OFF = "off",
+    CREATED = "created",
+    SHUTTED = "shutted",
+    WAITING = "waiting"
+}
+interface StatusResponse {
+    status: "ok" | "error";
+    services: {
+        fastify: boolean;
+        mongo: {
+            ok: boolean;
+            latency: number;
+        };
+        redis: {
+            ok: boolean;
+            latency: number;
+        };
+    };
+    timestamp: string;
+}
+
+type FetchOptions$7 = {
+    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>;
+declare class GuildBetUserManager extends BaseManager<GuildBetUser> {
+    constructor(guild: Guild);
+    fetch<T extends FetchOptions$7>(options?: T): Promise<ReturnFetchOptions$5<T>>;
+    updateMany(...betusers: Optional<APIGuildBetUser>[]): Promise<Collection<string, GuildBetUser>>;
+    deleteAll(): Promise<void>;
+    resetAll(): Promise<GuildBetUser | Collection<string, GuildBetUser>>;
+    set(data: APIGuildBetUser | APIGuildBetUser[]): GuildBetUser | Collection<string, GuildBetUser>;
+}
+
+declare class GuildBetUser implements APIGuildBetUser {
+    #private;
+    /** User daily */
+    daily: Omit<Daily, "points">;
+    profile: Profile;
+    /** User's name */
+    id: string;
+    guild_id: string;
+    /** User's credit */
+    credit: number;
+    /** User's wins */
+    wins: number;
+    /** User's mvps */
+    mvps: number;
+    /** User's losses */
+    losses: number;
+    /** User's games */
+    games: number;
+    /** User's blacklist */
+    blacklist: boolean;
+    /** User's coins */
+    coins: number;
+    spins: number;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    consecutive_wins: number;
+    /** The given manager */
+    readonly manager: GuildBetUserManager;
+    /** The rest client */
+    readonly rest: REST;
+    readonly guild: Guild;
+    /**
+     * Bet user
+     * @param data  The user's data
+     * @param manager The manager
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildBetUser, manager: GuildBetUserManager);
+    /** String representation of this user */
+    toString(): string;
+    /**
+     * Fetches the user
+     * @returns New Instance of the user
+     */
+    fetch(): Promise<GuildBetUser>;
+    /**
+     * Set the user blacklist
+     * @param value Value to set to
+     * @returns GuildBetUser
+     */
+    setBlacklist(value: boolean): Promise<this>;
+    reset(): Promise<this>;
+    updateProfile(data: Optional<Profile>): Promise<this>;
+    /**
+     * Update certain property
+     * @param data The new data to update with
+     * @returns
+     */
+    update(data: Omit<Optional<APIGuildBetUser>, "daily"> & {
+        type?: "add" | "remove";
+    }): Promise<this>;
+    _update(data: Omit<Optional<APIGuildBetUser>, "daily">): Promise<this>;
+    delete(): Promise<boolean>;
+    toJSON(): Optional<APIGuildBetUser>;
+}
+
+declare class GuildMatch {
+    #private;
+    _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 maximum size */
+    maximumSize: number;
+    /** Match's kicked out */
+    kickedOut: APIPlayer[];
+    /** Match's confirmed */
+    confirmed: Confirm[];
+    /** Match's leaders */
+    leaders: APIPlayer[];
+    /** Match's creator id */
+    creatorId: string;
+    /** Match's room creator id */
+    roomCreatorId: string;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    messages: MessagesManager<GuildMatch>;
+    /** Match's id */
+    mvps: [];
+    manager: GuildMatchManager;
+    bet: GuildBet;
+    admin_id: string;
+    /** The given guild */
+    readonly guild: Guild;
+    /** The rest client */
+    readonly rest: REST;
+    readonly key: string;
+    /**
+     * GuildMatch match
+     * @param data  The match's data
+     * @param guild The guild
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildMatch, manager: GuildMatchManager);
+    /**
+     * Fetches the match
+     * @returns New Instance of the match
+     */
+    fetch(): Promise<GuildMatch>;
+    addConfirmed(type: string, id: string | string[]): Promise<GuildMatch>;
+    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>;
+    setMvps(...usersId: string[]): Promise<GuildMatch>;
+    setRoomCreatorId(userId: string): Promise<GuildMatch>;
+    setRoomAdminId(userId: string): Promise<GuildMatch>;
+    kick(player: Optional<APIPlayer>): Promise<GuildMatch>;
+    update(data: Optional<APIGuildMatch>): Promise<GuildMatch>;
+    delete(): Promise<boolean>;
+    toJSON(): Optional<APIGuildMatch>;
+}
+
+type FetchOptions$6 = {
+    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>;
+declare class GuildUserManager extends BaseManager<GuildUser> {
+    constructor(guild: Guild);
+    fetch<T extends FetchOptions$6>(options?: T): Promise<ReturnFetchOptions$4<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>;
+}
+
+declare class GuildUser implements APIGuildUser {
+    #private;
+    /** User's id */
+    id: string;
+    guild_id: string;
+    /** User's daily */
+    daily: Omit<Daily, "credit">;
+    /** User's points */
+    points: number;
+    /** User's wins */
+    wins: number;
+    /** User's mvps */
+    mvps: number;
+    /** User's losses */
+    losses: number;
+    /** User's games */
+    games: number;
+    /** If user is blacklisted */
+    blacklist: boolean;
+    /** User's accessories such as double point */
+    accessories: Accessory[];
+    /** User's original channels */
+    original_channels: OriginalChannels;
+    profile: Profile;
+    creations: number;
+    /** User's items */
+    adverts: APIAdvert[];
+    spins: number;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** The given manager */
+    readonly manager: GuildUserManager;
+    /** The rest client */
+    readonly rest: REST;
+    /**
+     * Bet user
+     * @param data  The user's data
+     * @param manager The manager
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildUser, manager: GuildUserManager);
+    /** String representation of this user */
+    toString(): string;
+    /**
+     * Fetches the user
+     * @returns New Instance of the user
+     */
+    fetch(): Promise<GuildUser>;
+    /**
+     * Set the user blacklist
+     * @param value Value to set to
+     * @returns GuildUser
+     */
+    setBlacklist(value: boolean): Promise<this>;
+    reset(): Promise<this>;
+    updateProfile(data: Optional<Profile>): Promise<this>;
+    addAdvert(data: Optional<Omit<APIAdvert, "_id">>): Promise<GuildUser>;
+    removeAdvert(advertId?: string): Promise<GuildUser>;
+    /**
+     * Update certain property
+     * @param data The new data to update with
+     * @returns
+     */
+    update(data: Omit<Optional<APIGuildUser>, "daily"> & {
+        type?: "add" | "remove";
+    }): Promise<this>;
+    delete(): Promise<boolean>;
+    toJSON(): APIGuildUser;
+}
+
+interface RequestOptions<Payload> {
+    /** The request's method */
+    method: "patch" | "get" | "put" | "post" | "delete" | "options" | "head" | "PATCH" | "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
+    /** The request's url */
+    url: string;
+    /** The request payload */
+    payload?: Payload;
+}
+interface RestEvents {
+    request: [{
+        url: string;
+        method: string;
+    }];
+    response: [{
+        status: number;
+        body: unknown;
+    }];
+    error: [Error];
+    debug: [string];
+    ticketCreate: [GuildTicket];
+    ticketDelete: [GuildTicket];
+    ticketsDelete: [Collection<string, GuildTicket>];
+    matchCreate: [GuildMatch];
+    matchUpdate: [GuildMatch, GuildMatch];
+    matchDelete: [GuildMatch];
+    matchesDelete: [Collection<string, GuildMatch>];
+    betCreate: [GuildBet];
+    betUpdate: [GuildBet, GuildBet];
+    betDelete: [GuildBet];
+    betsDelete: [Collection<string, GuildBet>];
+    guildUpdate: [Guild];
+    guildDelete: [Guild];
+    guildsDelete: [Collection<string, Guild>];
+    userDelete: [GuildUser];
+    userUpdate: [GuildUser];
+    usersDelete: [Collection<string, GuildUser>];
+    betuserDelete: [GuildBetUser];
+    betuserUpdate: [GuildBetUser];
+    betusersDelete: [Collection<string, GuildBetUser>];
+    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 {
+    #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 LogEntry {
+    #private;
+    _id: string;
+    guild_id: string;
+    user_id: string;
+    admin_id: string;
+    object_id: string;
+    type: LogEntryTypes;
+    description: string;
+    change: string;
+    before: any;
+    after: any;
+    logs_channel_id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    manager: LogManager;
+    /** The given guild */
+    readonly guild: Guild;
+    /** The rest client */
+    readonly rest: REST;
+    constructor(data: APILogEntry, manager: LogManager);
+    fetch(): Promise<LogEntry>;
+    toJSON(): Record<string, unknown>;
+}
+
+type FetchOptions$5 = {
+    mediatorId?: string;
+    cache?: boolean;
+};
+declare class GuildMediatorManager extends BaseManager<GuildMediator> {
+    constructor(guild: Guild);
+    fetch(options?: FetchOptions$5): Promise<Collection<string, GuildMediator> | GuildMediator>;
+    updateMany(...mediators: Optional<APIGuildMediator>[]): Promise<Collection<string, GuildMediator>>;
+    create(payload: Optional<APIGuildMediator>): Promise<GuildMediator>;
+    deleteAll(): Promise<void>;
+    resetAll(): Promise<Collection<string, GuildMediator>>;
+    set(data: APIGuildMediator | APIGuildMediator[]): GuildMediator | Collection<string, GuildMediator>;
+}
+
+declare class GuildMediator implements APIGuildMediator {
+    #private;
+    /** User's name */
+    id: string;
+    guild_id: string;
+    /** User's games */
+    games: number;
+    paypal: string;
+    revolut: string;
+    mbway: string;
+    external_links: string[];
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** The given manager */
+    readonly manager: GuildMediatorManager;
+    /** The rest client */
+    readonly rest: REST;
+    readonly guild: Guild;
+    /**
+     * Bet user
+     * @param data  The user's data
+     * @param manager The manager
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildMediator, manager: GuildMediatorManager);
+    /** String representation of this user */
+    toString(): string;
+    /**
+     * Fetches the user
+     * @returns New Instance of the user
+     */
+    fetch(): Promise<GuildMediator>;
+    reset(): Promise<this>;
+    /**
+     * Update certain property
+     * @param data The new data to update with
+     * @returns
+     */
+    update(data: Optional<APIGuildMediator>): Promise<this>;
+    setPaymentlink(type: string, link: string): Promise<this>;
+    delete(): Promise<boolean>;
+    toJSON(): Optional<APIGuildMediator>;
+}
+
+type FecthOptions$1 = {
+    cache?: boolean;
+    memberId?: string;
+};
+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);
+    create(data: Optional<APIVipMember>): Promise<VipMember>;
+    /**
+     * Fetch a member
+     * @param id Id of the member to fetch
+     * @returns VipMember
+     */
+    fetch(options?: FecthOptions$1): 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>;
+}
+
+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>;
+}
+
+declare class GuildTicket implements APIGuildTicket {
+    #private;
+    _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: APIMessage[];
+    createdAt: Date;
+    updatedAt: Date;
+    readonly rest: REST;
+    readonly guild: Guild;
+    readonly manager: GuildTicketManager;
+    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<APIMessage>): Promise<GuildTicket>;
+}
+
+interface FetchOptions$4 {
+    cache?: boolean;
+    gameId?: string;
+}
+declare class MinesGameManager {
+    cache: Collection<string, MinesGame>;
+    readonly rest: REST;
+    constructor(rest: REST);
+    create(data: Optional<APIMinesGame>): Promise<MinesGame>;
+    delete(gameId: string): Promise<unknown>;
+    fetch(options?: FetchOptions$4): Promise<MinesGame | Collection<string, MinesGame>>;
+    set(data: APIMinesGame | APIMinesGame[]): MinesGame | Collection<string, MinesGame>;
+}
+
+declare class MinesGame {
+    #private;
+    guild_id: string;
+    _id: string;
+    creatorId: string;
+    maxMines: number;
+    bombs: number;
+    bombsPosition: number[];
+    bet: number;
+    multiplier: number;
+    status: "created" | "won" | "lost" | "expired";
+    createdAt: Date;
+    updatedAt: Date;
+    readonly rest: REST;
+    readonly manager: MinesGameManager;
+    constructor(data: APIMinesGame, manager: MinesGameManager);
+    fetch(): Promise<this>;
+    delete(): Promise<this>;
+    update(data: Optional<APIMinesGame>): Promise<this>;
+}
+
+declare class Tournament {
+    #private;
+    _id: string;
+    guild_id: string;
+    type: string;
+    max_teams: number;
+    teams: APIPlayer[][];
+    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: string;
+        max_teams: number;
+        teams: APIPlayer[][];
+        message: any;
+        message_id: string;
+        status: "on" | "off" | "created";
+        createdAt: Date;
+        updatedAt: Date;
+    };
+}
+
+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 Guild {
+    #private;
+    /** The data of this guild */
+    data: APIGuild;
+    /** The rest client */
+    rest: REST;
+    /** The guild's id */
+    id: string;
+    modes: GuildModes;
+    /** Guild's client key */
+    client_key: string;
+    /** Guild Permissions */
+    permissions: APIGuildPermissions;
+    /** Guild Ticket */
+    tickets: GuildTicketManager;
+    /** Guild Ticket Configuration */
+    tickets_configuration: GuildTicketConfiguration;
+    /** Guild Daily Categories */
+    daily_categories: DailyCategories[];
+    /** Guild Scores */
+    scores: GuildScores;
+    /** Guild Status */
+    status: GuildStatus;
+    channels: APIGuildGroupedChannel[];
+    roulette_settings: RouletteSettings;
+    /** Guild Prefix */
+    prefix: string;
+    prefixes: string[];
+    /** Guild Creation Date */
+    createdAt: Date;
+    /** Guild Updated Date */
+    updatedAt: Date;
+    /** Guild Matches */
+    matches: GuildMatchManager;
+    /** Guild Prices Used */
+    prices: GuildPrices;
+    permissionsManager: GuildPermissionManager;
+    buffer: BufferManager;
+    vipMembers: VipMemberManager;
+    users: GuildUserManager;
+    logEntries: LogManager;
+    shop: APIGuildShop;
+    betusers: GuildBetUserManager;
+    bets: GuildBetManager;
+    mediators: GuildMediatorManager;
+    automatic_messages: APIAutomaticMessage[];
+    automaticMessagesManager: AutomaticMessageManager;
+    tournaments: TournamentManager;
+    adverts: APIGuildAdvert[];
+    codes: APICode[];
+    coin_symbol: string;
+    /**
+     * The guild structure
+     * @param data The guild's data
+     * @param rest The rest client
+     */
+    constructor(data: APIGuild, rest: REST);
+    getChannel(type: GuildChannelsType): Promise<APIGuildGroupedChannel>;
+    getPermission(type: GuildPermissionsTypes): Promise<Permission>;
+    createAdvert(data: Optional<APIGuildAdvert>): Promise<this>;
+    removeAdvert(advertId: string): Promise<this>;
+    createCode(data: Optional<APICode>): Promise<this>;
+    removeCode(codeId: string): Promise<this>;
+    addIdToChannel(type: GuildChannelsType, id: string | string[]): Promise<this>;
+    setChannelIds(type: GuildChannelsType, ...ids: string[]): Promise<this>;
+    removeIdInChannel(type: GuildChannelsType, id: string | string[]): Promise<this>;
+    updateRouletteSettings(data: Optional<RouletteSettings> & {
+        default?: boolean;
+    }): 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> & {
+        reset?: boolean;
+    }): Promise<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>;
+    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 = {
+    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 DeleteOptions$1 = {
+    guildId?: string;
+};
+declare class GuildManager {
+    /** A cache of guilds */
+    cache: Collection<string, Guild>;
+    /** The rest client */
+    rest: REST;
+    /**
+     * Manage guilds with the given client
+     * @param guilds An array of guilds
+     * @param rest The rest client
+     */
+    constructor(rest: REST);
+    /**
+     * Fetch a guild
+     * @param id Id of the guild to fetch
+     * @returns APIGuild
+     */
+    fetch<T extends FetchOptions$2>(options?: T): Promise<ReturnFetchOptions$2<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>;
+}
+
+interface ClientOptions {
+    clientKey: string;
+    guildId: string;
+    authKey: string;
+}
+/**
+ * The main class of this package
+ */
+declare class REST extends EventEmitter {
+    /**
+     * The unique key for client
+     */
+    clientKey: string;
+    authKey: string;
+    guildId: string;
+    /** The guild manager */
+    guilds: GuildManager;
+    minesGames: MinesGameManager;
+    users: Collection<string, GuildUser>;
+    betusers: Collection<string, GuildBetUser>;
+    matches: Collection<string, GuildMatch>;
+    bets: Collection<string, GuildBet>;
+    tickets: Collection<string, GuildTicket>;
+    vipmembers: Collection<string, VipMember>;
+    mediators: Collection<string, GuildMediator>;
+    /**
+     *
+     * @param key The unique key for he client
+     */
+    constructor(options: ClientOptions);
+    /** Initialize the caching sistem */
+    init(): Promise<this>;
+    formatUrl(url: string): string;
+    /**
+     * Request Data from a certain url
+     * @param options
+     * @returns
+     */
+    request<Expecting, Payload>(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;
+    once<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void): this;
+}
+
+declare class BaseManager<S extends object> {
+    /** This url of the manager */
+    base_url: string;
+    /** The rest client */
+    rest: REST;
+    /** The guild of the manager */
+    guild: Guild;
+    /** 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;
+}
+
+declare class AutomaticMessageManager extends BaseManager<AutomaticMessage> {
+    constructor(guild: Guild);
+    fetch<T extends string>(messageId?: T): Promise<Collection<string, AutomaticMessage>>;
+    create(data: Optional<APIAutomaticMessage>): Promise<AutomaticMessage>;
+    _add(data: APIAutomaticMessage | APIAutomaticMessage[]): Collection<string, AutomaticMessage>;
+    set(data: APIAutomaticMessage | APIAutomaticMessage[]): Collection<string, APIAutomaticMessage>;
+    delete(messageId?: string): Promise<APIGuild | Collection<string, APIAutomaticMessage>>;
+    toJSON(): AutomaticMessage[];
+}
+
+interface FetchOptions$1 {
+    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>;
+declare class GuildBetManager extends BaseManager<GuildBet> {
+    constructor(guild: Guild);
+    toString(): number;
+    fetch<T extends FetchOptions$1>(options?: T): Promise<ReturnFetchOptions$1<T>>;
+    create(data: Optional<APIGuildBet>): Promise<GuildBet>;
+    delete(betId?: string): Promise<GuildBet>;
+    set(data: Optional<APIGuildBet> | Optional<APIGuildBet>[] | GuildBet): GuildBet;
+}
+
+type BufferMatch = Optional<APIGuildMatch & {
+    id: string;
+}>;
+type BufferTicket = Optional<APIGuildTicket & {
+    id: string;
+}>;
+declare class BufferManager {
+    matches: Collection<string, BufferMatch | GuildMatch>;
+    tickets: Collection<string, BufferTicket>;
+    guild: Guild;
+    constructor(guild: Guild);
+    flush(key: "matches" | "tickets"): Promise<APIGuildMatch[] & APIGuildTicket[]>;
+    createMatch(id: string, data: BufferMatch): void;
+    createTicket(id: string, data: BufferTicket): void;
+}
+
+declare class LogManager extends BaseManager<LogEntry> {
+    constructor(guild: Guild);
+    fetch(): Promise<Collection<string, LogEntry>>;
+    create(data: Optional<APILogEntry>): Promise<LogEntry>;
+    set(data: APILogEntry | APILogEntry[]): LogEntry | Collection<string, LogEntry>;
+}
+
+type FetchOptions = {
+    cache: boolean;
+    matchId: string;
+};
+type ReturnFetchOptions<T extends FetchOptions> = 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
+     * @param users An array of users
+     * @param rest The rest client
+     */
+    constructor(guild: Guild);
+    /**
+     * Fetch a match
+     * @param id Id of the match to fetch
+     * @returns APIBetUser
+     */
+    fetch<T extends FetchOptions>(options?: T): Promise<ReturnFetchOptions<T>>;
+    fetchAll(): Promise<Collection<string, GuildMatch>>;
+    set(data: APIGuildMatch | APIGuildMatch[] | GuildMatch): GuildMatch | Collection<string, GuildMatch>;
+    create(payload: Optional<APIGuildMatch>): Promise<GuildMatch>;
+    delete(id?: string): Promise<GuildMatch | Collection<string, GuildMatch>>;
+}
+
+type T<e> = e & {
+    rest: REST;
+    guild: Guild;
+    messages: MessagesManager<e>;
+};
+declare class MessagesManager<Structure> {
+    cache: Collection<string, APIMessage>;
+    readonly base_url: string;
+    readonly rest: REST;
+    readonly guild: Guild;
+    constructor(structure: T<Structure>, base_url: string);
+    fetch(): Promise<APIMessage>;
+    create(data: Optional<APIMessage> | Optional<APIMessage>[]): Promise<Collection<string, APIMessage>>;
+    set(data: APIMessage | APIMessage[]): Collection<string, APIMessage>;
+}
+
+declare class GuildPermissionManager extends BaseManager<APIGuildPermissions> {
+    constructor(guild: Guild);
+    addRole(type: GuildPermissionsTypes, ...ids: string[]): Promise<APIGuild>;
+    removeRole(type: GuildPermissionsTypes, ...ids: string[]): Promise<APIGuild>;
+}
+
+type FecthOptions = {
+    ticketId?: string;
+    cache?: boolean;
+};
+type DeleteOptions = {
+    ticketId?: string;
+};
+declare class GuildTicketManager {
+    cache: Collection<string, GuildTicket>;
+    readonly guild: Guild;
+    readonly rest: REST;
+    constructor(guild: Guild);
+    createTicketCategory(data: Optional<APITicketCategory>): Promise<Guild>;
+    deleteTicketCategory(data: Optional<APITicketCategory>): Promise<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 { 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 };