ahegao 1.69.27 → 1.69.28

package/dist/types/discord_classes.d.ts

@@ -0,0 +1,80 @@
+import { Channel, Client, Collection, Guild, GuildBasedChannel, GuildMember, InteractionReplyOptions, Message, MessagePayload, MessageReference, TextBasedChannel, TextChannel, ThreadChannel, User } from "discord.js";
+import { CommandType, SendOptions } from "./discord_types";
+import { MESSAGE_TYPE, RECIPIENT_TYPE } from "./discord_fields";
+import { ExtendedInteraction, MessageType } from "../utils/discord-util";
+export declare class BaseDiscordClient extends Client {
+    readonly commands: Collection<string, CommandType>;
+    private noAccessGuilds;
+    private noAccessChannels;
+    private noAccessMessages;
+    private userCache;
+    private channelCache;
+    private slashCommands;
+    private readyToPostReactionQueue;
+    readonly name: string;
+    readonly nameLower: string;
+    protected styledName: string;
+    protected styledNameLower: string;
+    protected fgColor: import("chalk").Chalk;
+    readonly defaultEmbedColor: number;
+    startMessage: string;
+    private starting;
+    private started;
+    constructor(name: string);
+    get userId(): string;
+    setDefaultStartMessage(): void;
+    setFgColor(chalkColor: any): void;
+    isStartedOrStarting(): boolean;
+    onBeforeStart(): Promise<void>;
+    onAfterStart(): Promise<void>;
+    onAfterCacheInit(): Promise<void>;
+    getPreviousMessageOfChannel(channel: TextBasedChannel, indexFromLast?: number): Promise<Message<boolean>>;
+    start(token: string, resourcesPath: string): Promise<void>;
+    onStartFail(): void;
+    onError(error: Error): void;
+    importFile(filePath: string): Promise<any>;
+    private registerToDiscord;
+    protected registerBotEvents(resourcesPath: string): Promise<void>;
+    log(message?: any): void;
+    private onReady;
+    protected registerEverything(resourcesPath: string): Promise<void>;
+    protected registerSlashCommands(resourcesPath: string): Promise<void>;
+    protected registerEvents(resourcesPath: string): Promise<void>;
+    edit(message: Message<boolean>, newContent: string): Promise<Message<boolean>>;
+    send(recipient: RECIPIENT_TYPE, message: MESSAGE_TYPE, options?: SendOptions): Promise<Message<boolean>>;
+    onEditedToReal(message: Message<boolean>): Promise<void>;
+    getUwuChance(): number;
+    getAiInterpretationChance(): number;
+    getAiRandomScenarioChance(): number;
+    sendToById(message: MESSAGE_TYPE, channelId: string, options?: SendOptions): Promise<Message<boolean>>;
+    trySendToById(messages: string[], channelId: string, options?: SendOptions): Promise<boolean>;
+    sendToByName(message: string | MessagePayload, guildId: string, channelName: string): Promise<Message<boolean>>;
+    dmUserById(userId: string, message: MESSAGE_TYPE): Promise<Message<boolean>>;
+    getOrCreateChannelByGuildName(guild: Guild, channelName: string): Promise<TextBasedChannel>;
+    findChannelByGuildName(guild: Guild, channelName: string): Promise<TextBasedChannel>;
+    findChannelByGuildIdName(guildId: string, channelName: string): Promise<TextBasedChannel>;
+    findGuildById(guildId: string): Promise<Guild>;
+    findMemberByGuildIdAndId(guildId: string, userId: string): Promise<GuildMember>;
+    findMemberByGuildAndId(guild: Guild, userId: string): Promise<GuildMember>;
+    findUserById(userId: string): Promise<User>;
+    findChannelById(channelId: string): Promise<Channel>;
+    memberHasRole(member: GuildMember, roleId: string): boolean;
+    trySetNickname(member: GuildMember, newName: string): Promise<boolean>;
+    followUp(interaction: ExtendedInteraction, options: string | MessagePayload | InteractionReplyOptions): Promise<Message<boolean>>;
+    renameGuildById(guildId: string, name: string): Promise<boolean>;
+    renameChannelById(channelId: string, name: string): Promise<boolean>;
+    renameMemberByGuildIdAndId(guildId: string, memberId: string, name: string): Promise<boolean>;
+    referenceToString(reference: MessageReference): Promise<string>;
+    delete(message: MessageType): Promise<boolean>;
+    setChannelMessagesTo(channel: TextChannel | ThreadChannel, msgs: string[]): Promise<void>;
+    stopIfDev(interaction: ExtendedInteraction): boolean;
+    stopIfNotTextChannel(interaction: ExtendedInteraction, channel: Channel): channel is Exclude<any, TextChannel>;
+    getUserNameById(userId: string): Promise<string>;
+    get loadingMessage(): string;
+    forEveryServer(doThis: (guild: Guild) => void | Promise<void>): Promise<void>;
+    forEveryMember(doThis: (member: GuildMember, guild: Guild) => void | Promise<void>): Promise<void>;
+    forEveryChannel(doThis: (channel: GuildBasedChannel, guild: Guild) => void | Promise<void>): Promise<void>;
+    getAllMembers(): Promise<Set<GuildMember>>;
+    getAllUsers(): Promise<Set<User>>;
+    getAllChannels(): Promise<Set<GuildBasedChannel>>;
+}

package/dist/types/discord_classes.js

@@ -0,0 +1,613 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDiscordClient = void 0;
+const util_1 = require("../utils/util");
+const discord_js_1 = require("discord.js");
+const discord_fields_1 = require("./discord_fields");
+const discord_util_1 = require("../utils/discord-util");
+const fields_1 = require("./fields");
+const mathjs_1 = require("mathjs");
+class BaseDiscordClient extends discord_js_1.Client {
+    constructor(name) {
+        super({
+            intents: 4194303,
+            closeTimeout: 120000,
+            waitGuildTimeout: 120000,
+        });
+        this.commands = new discord_js_1.Collection();
+        this.noAccessGuilds = new Set();
+        this.noAccessChannels = new Set();
+        this.noAccessMessages = new Set();
+        this.userCache = new Map();
+        this.channelCache = new Map();
+        this.slashCommands = [];
+        this.readyToPostReactionQueue = true;
+        this.fgColor = util_1.chalk.whiteBright;
+        this.defaultEmbedColor = 0xff0077;
+        this.starting = false;
+        this.started = false;
+        // super({ intents: [32767, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages] })
+        this.name = name;
+        this.styledName = this.fgColor(this.name);
+        this.nameLower = name.toLocaleLowerCase();
+        this.styledNameLower = this.fgColor(this.nameLower);
+        this.setFgColor(this.fgColor);
+        this.startMessage = this.fgColor(`-${this.name} Sounds-`);
+    }
+    get userId() {
+        return this.user.id;
+    }
+    setDefaultStartMessage() {
+        this.startMessage = this.fgColor(`-${this.name} Sounds-`);
+    }
+    setFgColor(chalkColor) {
+        this.fgColor = chalkColor;
+        this.styledName = this.fgColor(this.name);
+        this.styledNameLower = this.fgColor(this.nameLower);
+    }
+    isStartedOrStarting() {
+        return this.starting || this.started;
+    }
+    async onBeforeStart() {
+    }
+    async onAfterStart() {
+    }
+    async onAfterCacheInit() {
+        // setupSpamPortals(this)
+    }
+    async getPreviousMessageOfChannel(channel, indexFromLast = 1) {
+        let messages = Array.from(channel.messages.cache.values());
+        if (messages.length < indexFromLast + 1) {
+            messages = Array.from((await channel.messages.fetch({ limit: indexFromLast + 1 })).values());
+        }
+        if (messages.length > 0) {
+            if (indexFromLast < messages.length) {
+                return messages[messages.length - indexFromLast];
+            }
+            return messages[messages.length - 1];
+        }
+        return null;
+    }
+    async start(token, resourcesPath) {
+        if (this.started) {
+            return;
+        }
+        await this.onBeforeStart();
+        this.starting = true;
+        await this.registerBotEvents(resourcesPath);
+        await this.login(token);
+        await this.onAfterStart();
+        this.starting = false;
+        this.started = true;
+        // extendThreadsTo7Days(this)
+    }
+    onStartFail() {
+        this.starting = false;
+        this.started = false;
+        this.log(`Failed to start ${this.styledName}`);
+    }
+    onError(error) {
+        this.starting = false;
+        this.started = false;
+        this.log(`Error: ${error.name}\n${error.stack ? `${error.stack}\n` : ""}${error.cause ? `${error.cause}\n` : ""}${error.message}`);
+    }
+    async importFile(filePath) {
+        var _a;
+        return (_a = (await Promise.resolve(`${filePath}`).then(s => __importStar(require(s))))) === null || _a === void 0 ? void 0 : _a.default;
+    }
+    async registerToDiscord({ commands, guildId }) {
+        var _a;
+        if (guildId) {
+            await ((_a = this.guilds.cache.get(guildId)) === null || _a === void 0 ? void 0 : _a.commands.set(commands));
+            this.log(`Registering ${commands.length} ${discord_fields_1.STYLED_SLASH_COMMANDS} to ${guildId}`);
+        }
+        else {
+            await this.application.commands.set(commands);
+            // this.log(`Registering ${commands.length} global slash commands`)
+        }
+    }
+    async registerBotEvents(resourcesPath) {
+        this.on("ready", () => this.onReady(resourcesPath));
+    }
+    log(message) {
+        // print(`${toStamp((Date.now() / 1000 % SECONDS_IN_DAY + SERVER_TIMEZONE_OFFSET_H * 3600) % SECONDS_IN_DAY)} ${this.styledName}: ${message}`)
+        (0, util_1.print)(message);
+    }
+    async onReady(resourcesPath) {
+        await this.registerEverything(resourcesPath);
+        await this.registerToDiscord({
+            commands: this.slashCommands,
+            guildId: process.env.guildId
+        });
+        this.log(this.startMessage);
+    }
+    async registerEverything(resourcesPath) {
+        await this.registerSlashCommands(resourcesPath);
+        await this.registerEvents(resourcesPath);
+    }
+    async registerSlashCommands(resourcesPath) {
+        const slashCommandsPath = (0, util_1.makeUnixPath)(resourcesPath, "slash_commands");
+        this.log(`Registering ${this.styledNameLower}...`);
+        const registeredCommands = new Set();
+        //Slash Commands
+        const slashCommandRegisterer = async (filePath) => {
+            const command = await this.importFile(filePath);
+            if (!command.name)
+                return;
+            if (command.options != null) {
+                for (const option of command.options) {
+                    if (option == null) {
+                        throw this.log(`Command ${command.name} option is null!`);
+                        continue;
+                    }
+                    if (option.name.length < 1 || option.name.length > 100) {
+                        throw new Error(`Command ${command.name} name is not 1<->100 length! ${option.name.length}`);
+                    }
+                    if (option.description.length < 1 || option.description.length > 100) {
+                        throw new Error(`Command ${command.description} description is not 1<->100 length! ${option.description.length}`);
+                    }
+                }
+            }
+            if (registeredCommands.has(command.name)) {
+                this.log(`${discord_fields_1.STYLED_WARNING}: Duplicate ${discord_fields_1.STYLED_SLASH_COMMAND} ${command.name}. ${util_1.chalk.underline(util_1.chalk.whiteBright("Skipping!"))}`);
+                return;
+            }
+            // this.log(`Registering ${STYLED_SLASH_COMMAND} ${command.name}`)
+            this.commands.set(command.name, command);
+            this.slashCommands.push(command);
+            registeredCommands.add(command.name);
+        };
+        const myCommandFilesPath = (0, util_1.makeUnixPath)(slashCommandsPath, this.nameLower, "*{.ts,.js}");
+        (0, util_1.dogPaths)(`myCommandFilesPath: "${myCommandFilesPath}"`);
+        const myCommandFiles = await (0, fields_1.globPromise)(myCommandFilesPath);
+        for (const slashCommand of myCommandFiles) {
+            await slashCommandRegisterer(slashCommand);
+        }
+        const sharedCommandFilesPath = (0, util_1.makeUnixPath)(slashCommandsPath, "shared", "*{.ts,.js}");
+        (0, util_1.dogPaths)(`sharedCommandFilesPath: "${sharedCommandFilesPath}"`);
+        const sharedCommandFiles = await (0, fields_1.globPromise)(sharedCommandFilesPath);
+        for (const slashCommand of sharedCommandFiles) {
+            await slashCommandRegisterer(slashCommand);
+        }
+        const slashCommandsCount = myCommandFiles.length + sharedCommandFiles.length;
+        this.log(`Registered ${myCommandFiles.length + sharedCommandFiles.length} ${(0, util_1.if1Else)(slashCommandsCount, discord_fields_1.STYLED_SLASH_COMMAND, discord_fields_1.STYLED_SLASH_COMMANDS)}.`);
+    }
+    async registerEvents(resourcesPath) {
+        const eventsPath = (0, util_1.makeUnixPath)(resourcesPath, "events");
+        //Event
+        const eventRegisterer = async (filePath) => {
+            const event = await this.importFile(filePath);
+            if (!event.enabled) {
+                return;
+            }
+            this.on(event.event, (...args) => event.run(this, ...args));
+            // this.log(`Registering ${STYLED_EVENT} ${event.event}`)
+        };
+        const myEventFilesPath = (0, util_1.makeUnixPath)(eventsPath, this.nameLower, "*{.ts,.js}");
+        (0, util_1.dogPaths)(`myEventFilesPath: "${myEventFilesPath}"`);
+        const myEventFiles = await (0, fields_1.globPromise)(myEventFilesPath);
+        for (const event of myEventFiles) {
+            await eventRegisterer(event);
+        }
+        const sharedEventFilesPath = (0, util_1.makeUnixPath)(eventsPath, "shared", "*{.ts,.js}");
+        (0, util_1.dogPaths)(`sharedEventFilesPath: "${sharedEventFilesPath}"`);
+        const sharedEventFiles = await (0, fields_1.globPromise)(sharedEventFilesPath);
+        for (const event of sharedEventFiles) {
+            await eventRegisterer(event);
+        }
+        const eventsCount = myEventFiles.length + sharedEventFiles.length;
+        this.log(`Registered ${eventsCount} ${(0, util_1.if1Else)(eventsCount, discord_fields_1.STYLED_EVENT, discord_fields_1.STYLED_EVENTS)}.`);
+    }
+    async edit(message, newContent) {
+        if (newContent.length > fields_1.DISCORD_MESSAGE_LENGTH_LIMIT) {
+            newContent = newContent.slice(0, 1996) + "...";
+            this.log(`Tried to edit a message to length ${newContent.length}; Slicing to ${fields_1.DISCORD_MESSAGE_LENGTH_LIMIT}...\n${newContent}`);
+        }
+        message = await message.edit(newContent);
+        return message;
+    }
+    async send(recipient, message, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
+        var _a, _b;
+        if (recipient == null) {
+            this.log(util_1.chalk.redBright(`Tried to send a message; no ["send"]! Recipient: ${typeof recipient} | ${recipient}`));
+            return null;
+        }
+        if (recipient == null) {
+            this.log(`bot.send: Null recipient:\n${message}`);
+            return null;
+        }
+        let content = ((0, util_1.isString)(message) ? message : (_a = message) !== null && _a !== void 0 ? _a : null);
+        if (content == null) {
+            return await recipient(message);
+        }
+        if (content.length <= 0) {
+            this.log(`Tried to send empty message`);
+            return null;
+        }
+        const dummyMessageEditToReal = (_b = options.dummyMessageEditToReal) !== null && _b !== void 0 ? _b : discord_fields_1.DEFAULT_DUMMY_MESSAGE_EDIT_TO_REAL;
+        if (options.uwuAllowed) {
+            if ((0, mathjs_1.random)() < this.getUwuChance()) {
+                const match = content.match(fields_1.LINK_REGEX);
+                if (match == null) {
+                    content = content
+                        .replaceAll(/[rl]/g, "w")
+                        .replaceAll(/[RL]/g, "W")
+                        .replaceAll("no", "nyo")
+                        .replaceAll("No", "Nyo")
+                        .replaceAll(/(oa|ro)/g, "aw")
+                        .replaceAll(/(Oa|Ro)/g, "Aw")
+                        // .replaceAll(/lem/g, "mlem")
+                        // .replaceAll(/Lem/g, "Mlem")
+                        .replaceAll("ni", "nyai")
+                        .replaceAll("Ni", "Nyai")
+                        .replaceAll("pon", "pown")
+                        .replaceAll("Pon", "Pown")
+                        .replace(/([.!?])(\s|$)/g, (_, punc, space) => `${punc} ${(0, discord_util_1.getRandomUwuFace)()}${space}`);
+                }
+            }
+        }
+        if ((0, discord_util_1.tooLongForDiscord)(content)) {
+            this.log(`Tried to send a message of length ${content}; Slicing to 2000`);
+            content = content.slice(0, 1996) + "...";
+        }
+        if (Math.random() <= 0.01523) {
+            if ((0, discord_util_1.tooLongForDiscord)(content.length + discord_fields_1.VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE.length + 1)) {
+                content += `\n${discord_fields_1.VERIFIED_BY_DISCORD_ADMINS_EASTER_EGG_MESSAGE}`;
+            }
+        }
+        let liveMsg = null;
+        if (dummyMessageEditToReal) {
+            liveMsg = await recipient((0, util_1.skyify)(content));
+            if (liveMsg != null) {
+                liveMsg = await this.edit(liveMsg, content);
+                this.onEditedToReal(liveMsg);
+            }
+        }
+        else {
+            liveMsg = await recipient(content);
+        }
+        return liveMsg;
+    }
+    async onEditedToReal(message) {
+    }
+    getUwuChance() {
+        return 0;
+    }
+    getAiInterpretationChance() {
+        return 0;
+    }
+    getAiRandomScenarioChance() {
+        return 0;
+    }
+    async sendToById(message, channelId, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
+        let channel = await this.findChannelById(channelId);
+        if (channel instanceof discord_js_1.TextChannel) {
+            return this.send(channel, message, options);
+        }
+        // else
+        // {
+        //     this.log(`NULL OR NON TextChannel CHANNEL IN BOT SEND: whereTo:${channelId}\n${new Error().stack.slice(0, 1000)}`)
+        // }
+        return null;
+    }
+    async trySendToById(messages, channelId, options = discord_fields_1.DEFAULT_SEND_OPTIONS) {
+        for (let message of messages) {
+            const trimmedMessage = message.trim();
+            if (trimmedMessage.length <= 0) {
+                continue;
+            }
+            if (trimmedMessage.length > fields_1.DISCORD_MESSAGE_LENGTH_LIMIT) {
+                this.log(`${discord_fields_1.STYLED_WARNING}: Tried to send a message that's too long ${trimmedMessage.length}. Trimming!`);
+                message = message.slice(0, 1999);
+            }
+            const sentMessage = await this.sendToById(message, channelId, options);
+            if (sentMessage == undefined) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async sendToByName(message, guildId, channelName) {
+        let channel = await this.findChannelByGuildIdName(guildId, channelName);
+        if (channel != null)
+            return this.send(channel, message);
+        else {
+            const error = new Error();
+            if (error.stack != null) {
+                this.log(`NULL CHANNEL IN BOT SEND: whereTo:${channelName}, guildId:${guildId}\n${error.stack.slice(0, 1000)}`);
+            }
+        }
+        return null;
+    }
+    async dmUserById(userId, message) {
+        try {
+            const user = this.users.cache.get(userId);
+            return this.send(user, (0, util_1.isString)(message) ? message.slice(0, 1999) : message).catch(err => { (0, util_1.print)(err); });
+            // this.findUserById(userId).then((user: User) =>
+            // {
+            //     this.send(user, message)
+            //     user.send(message.slice(0, 1999))
+            // })
+        }
+        catch (err) {
+            this.log(`pmUserById ERROR: id:${userId}, \n${err.stack.slice(0, 1000)}`);
+        }
+        return null;
+    }
+    async getOrCreateChannelByGuildName(guild, channelName) {
+        let channel = await this.findChannelByGuildName(guild, channelName);
+        if (channel == null) {
+            try {
+                channel = await guild.channels.create({ name: channelName });
+            }
+            catch (err) {
+                this.log(util_1.chalk.redBright(`Could not create channel in guild: ${guild.id} ${guild.name}, channel: ${channelName}\n${err}`));
+            }
+        }
+        return channel;
+    }
+    async findChannelByGuildName(guild, channelName) {
+        for (const channel of guild.channels.cache.values()) {
+            if (channel.name == channelName) {
+                return channel;
+            }
+        }
+        const fetchedChannels = await guild.channels.fetch();
+        if (fetchedChannels != null) {
+            for (const channel of fetchedChannels.values()) {
+                if (channel.name == channelName) {
+                    return channel;
+                }
+            }
+        }
+        return null;
+    }
+    async findChannelByGuildIdName(guildId, channelName) {
+        const guild = await this.findGuildById(guildId);
+        if (guild == null) {
+            return null;
+        }
+        const channel = await this.findChannelByGuildName(guild, channelName);
+        if (channel == null) {
+            this.log(`Channel ${channelName} not found!`);
+        }
+        return channel;
+    }
+    async findGuildById(guildId) {
+        if (this.noAccessGuilds.has(guildId)) {
+            return null;
+        }
+        let guild = null;
+        try {
+            guild = this.guilds.cache.get(guildId);
+            if (guild == null) {
+                guild = await this.guilds.fetch(guildId);
+            }
+        }
+        catch (ignored) { }
+        if (guild == null) {
+            this.noAccessGuilds.add(guildId);
+        }
+        return guild;
+    }
+    async findMemberByGuildIdAndId(guildId, userId) {
+        const guild = await this.findGuildById(guildId);
+        if (guild != null) {
+            return this.findMemberByGuildAndId(guild, userId);
+        }
+        return undefined;
+    }
+    async findMemberByGuildAndId(guild, userId) {
+        let member = guild.members.cache.get(userId);
+        if (member != null) {
+            return member;
+        }
+        try {
+            return await guild.members.fetch(userId);
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    async findUserById(userId) {
+        const user = this.userCache.get(userId);
+        if (user != null) {
+            return user;
+        }
+        return this.users.cache.has(userId) ? this.users.cache.get(userId) : await this.users.fetch(userId);
+    }
+    async findChannelById(channelId) {
+        if (this.noAccessChannels.has(channelId)) {
+            return null;
+        }
+        let channel = this.channelCache.get(channelId);
+        if (channel != null) {
+            return channel;
+        }
+        channel = this.channels.cache.get(channelId);
+        if (channel != null) {
+            return channel;
+        }
+        else {
+            try {
+                return (await this.channels.fetch(channelId));
+            }
+            catch (err) {
+                this.noAccessChannels.add(channelId);
+            }
+        }
+        return null;
+    }
+    memberHasRole(member, roleId) {
+        return member.roles.cache.has(roleId);
+    }
+    async trySetNickname(member, newName) {
+        try {
+            const oldName = member.nickname;
+            await member.setNickname(newName);
+            this.log(`${oldName} changed to ${newName}`);
+        }
+        catch (_a) {
+            this.log(`Couldn't set name!`);
+            return false;
+        }
+        return true;
+    }
+    async followUp(interaction, options) {
+        this.log(`Interaction: ${(0, discord_util_1.wrapTitle)(interaction.commandName)} followUp: ${(0, util_1.isString)(options) ? options : `\n${(0, util_1.stringify)(options)}`}`);
+        try {
+            return await interaction.followUp(options);
+        }
+        catch (_a) {
+            (0, util_1.print)(util_1.chalk.redBright(`Error following up interaction; probably timed out! Oh well! Followup message:\n${options}`));
+        }
+        return null;
+    }
+    async renameGuildById(guildId, name) {
+        const guild = await this.findGuildById(guildId);
+        if (guild == null) {
+            return false;
+        }
+        (0, discord_util_1.renameGuildOrChannel)(guild, name);
+        return true;
+    }
+    async renameChannelById(channelId, name) {
+        const channel = await this.findChannelById(channelId);
+        if (!(channel instanceof discord_js_1.TextChannel)) {
+            return false;
+        }
+        await (0, discord_util_1.renameGuildOrChannel)(channel, name);
+        return true;
+    }
+    async renameMemberByGuildIdAndId(guildId, memberId, name) {
+        const member = await this.findMemberByGuildIdAndId(guildId, memberId);
+        if (member == null) {
+            return false;
+        }
+        await (0, discord_util_1.renameMember)(member, name);
+        return true;
+    }
+    async referenceToString(reference) {
+        var _a;
+        let referenceString = "";
+        if (reference != null) {
+            try {
+                const referenceChannel = await this.findChannelById(reference.channelId);
+                const referenceMessage = await referenceChannel.messages.fetch((_a = reference.messageId) !== null && _a !== void 0 ? _a : "");
+                referenceString = (0, discord_util_1.messageToReplyString)(referenceMessage);
+            }
+            catch (err) {
+                this.log(util_1.chalk.redBright(err));
+            }
+        }
+        return referenceString;
+    }
+    async delete(message) {
+        if (message == null) {
+            return false;
+        }
+        try {
+            await message.delete();
+            return true;
+        }
+        catch (err) {
+            this.log(`Error deleting message:\n${err}`);
+        }
+        return false;
+    }
+    async setChannelMessagesTo(channel, msgs) {
+        await (0, discord_util_1.forEachMessage)(channel, async (msg) => {
+            (0, util_1.print)(`Deleting old message ${msg.content}`);
+            await this.delete(msg);
+        });
+        for (const msg of msgs) {
+            const liveMsg = await this.send(channel, msg, discord_fields_1.AI_NOT_ALLOWED);
+            (0, util_1.print)(`Posted new message ${liveMsg.content}`);
+        }
+    }
+    stopIfDev(interaction) {
+        if ((0, discord_util_1.isDev)()) {
+            this.followUp(interaction, discord_util_1.COMMAND_NOT_ALLOWED_IN_DEV_MESSAGE);
+            return true;
+        }
+        return false;
+    }
+    stopIfNotTextChannel(interaction, channel) {
+        if (interaction.channel == null) {
+            return false;
+        }
+        if ((0, discord_util_1.isNotTextChannel)(interaction.channel)) {
+            this.followUp(interaction, discord_util_1.ONLY_TEXT_CHANNEL_SUPPORTED);
+            return false;
+        }
+        return true;
+    }
+    async getUserNameById(userId) {
+        return (0, discord_util_1.getUserName)(await this.findUserById(userId));
+    }
+    get loadingMessage() {
+        return `Loading~`;
+    }
+    async forEveryServer(doThis) {
+        await this.guilds.fetch();
+        for (const guild of this.guilds.cache.values()) {
+            await doThis(guild);
+        }
+    }
+    async forEveryMember(doThis) {
+        await this.forEveryServer(guild => (0, discord_util_1.forEveryMemberInGuild)(guild, member => doThis(member, guild)));
+    }
+    async forEveryChannel(doThis) {
+        await this.forEveryServer(guild => (0, discord_util_1.forEveryChannelInGuild)(guild, channel => doThis(channel, guild)));
+    }
+    async getAllMembers() {
+        const members = new Set();
+        await this.forEveryMember(member => { members.add(member); });
+        return members;
+    }
+    async getAllUsers() {
+        const users = new Set();
+        await this.forEveryMember(member => { users.add(member.user); });
+        return users;
+    }
+    async getAllChannels() {
+        const channels = new Set();
+        await this.forEveryChannel(channel => { channels.add(channel); });
+        return channels;
+    }
+}
+exports.BaseDiscordClient = BaseDiscordClient;
+//# sourceMappingURL=discord_classes.js.map