src/automod/Logger.ts

import { roleMention } from '@discordjs/builders';
import { BanOptions, CommandInteraction, FileOptions, Guild, GuildBan, GuildMember, Message, MessageEmbed, MessageOptions, MessagePayload, TextChannel, User } from 'discord.js';
import ms from 'ms';
import DiscordClient from '../client/Client';
import Punishment from '../models/Punishment';
import { timeProcess, timeSince } from '../utils/util';

class Logger {
    client: DiscordClient;

    constructor(client: DiscordClient) {
        this.client = client;
    }

    channel(callback: (channel: TextChannel) => any, msg: any) {
        let channelID = this.client.config.props[msg.guild!.id].logging_channel;
        let channel = msg.guild!.channels.cache.find((c: any) => c.id === channelID) as TextChannel;

        if (channel) {
            return callback(channel);
        }
    }

    channelJoinLeft(callback: (channel: TextChannel) => any, msg: any) {
        let channelID = this.client.config.props[msg.guild!.id].logging_channel_join_leave;
        let channel = msg.guild!.channels.cache.find((c: any) => c.id === channelID) as TextChannel;

        if (channel) {
            return callback(channel);
        }
    }

    async send(guild: Guild, messageOptions: MessageOptions | MessagePayload | string) {
        let channelID = this.client.config.props[guild!.id].logging_channel;
        let channel = guild!.channels.cache.find((c: any) => c.id === channelID) as TextChannel;

        if (channel) {
            return await channel.send(messageOptions);
        }
    }

    log(guild: Guild, callback: (channel: TextChannel) => any) {
        this.channel(callback, { guild });
    }

    logEdit(oldMsg: Message, newMsg: Message) {
        this.channel(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#007bff')
                    .setTitle('Message Edited in #' + (newMsg.channel as TextChannel).name + " (" + newMsg.channel.id + ")")
                    .setDescription('**-+-+Before**\n' + oldMsg.content + '\n\n**-+-+After**\n' + newMsg.content)
                    .addField('ID', newMsg.id)
                    .setAuthor({
                        name: newMsg.author.tag,
                        iconURL: newMsg.author.displayAvatarURL(),
                    })
                    .setFooter({
                        text: "Edited",
                    })
                    .setTimestamp()
                ]
            });
        }, newMsg);
    }

    logDelete(msg: Message) {
        this.channel(async (channel) => {
            const embed = new MessageEmbed()
                .setColor('#f14a60')
                .setTitle('Message Deleted in #' + (msg.channel as TextChannel).name + " (" + msg.channel.id + ")")
                .setDescription(msg.content)
                .setAuthor({
                    name: msg.author.tag,
                    iconURL: msg.author.displayAvatarURL(),
                })
                .addField('ID', msg.id)
                .setFooter({
                    text: "Deleted",
                })
                .setTimestamp();
            
            const files: FileOptions[] = [];

            if (msg.attachments.size > 0) {
                let str = '';

                msg.attachments.forEach(a => {
                    str += `${a.name}\n`;
                    files.push({
                        name: a.name!,
                        attachment: a.proxyURL
                    });
                });

                embed.addField('Attachments (top)', str);
            }

            await channel.send({
                embeds: [
                    embed
                ],
                files
            });
        }, msg);
    }

    logBanned(ban: GuildBan) {
        this.channel(async (channel) => {
            let r = '*No reason provided*';

            const auditLog = (await ban.guild.fetchAuditLogs({
                limit: 1,
                type: 'MEMBER_BAN_ADD',
            })).entries.first();           
      

            if (ban.reason) {
                r = ban.reason;
            }
            else if (auditLog) {
                console.log(auditLog);  
                const { target, reason } = await auditLog;

                if (target!.id === ban.user.id && reason) {
                    r = await reason;
                }
            }

            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setTitle("A user was banned")
                    .setAuthor({
                        name: ban.user.tag,
                        iconURL: ban.user.displayAvatarURL(),
                    })
                    .addField('Reason', r)
                    .addField('User ID', ban.user.id)
                    .setFooter({
                        text: "Banned",
                    })
                    .setTimestamp()
                ]
            });
        }, ban);
    }

    logSoftBan(banOptions: BanOptions, guild: Guild, user: User, model: Punishment) {
        this.channel(async (channel) => {
            let r = '*No reason provided*';

            const auditLog = (await guild.fetchAuditLogs({
                limit: 1,
                type: 'MEMBER_BAN_ADD',
            })).entries.first();         

            if (banOptions.reason) {
                r = banOptions.reason;
            }
            else if (auditLog) {
                console.log(auditLog);  
                const { target, reason } = await auditLog;

                if (target!.id === user.id && reason) {
                    r = await reason;
                }
            }

            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setTitle("A user was softbanned")
                    .setAuthor({
                        name: user.tag,
                        iconURL: user.displayAvatarURL(),
                    })
                    .addField('Reason', r)
                    .addField('Softbanned by', model.get().mod_tag)
                    .addField('User ID', user.id)
                    .setFooter({
                        text: "Softbanned",
                    })
                    .setTimestamp()
                ]
            });
        }, {
            guild
        });
    }

    logTempBan(banOptions: BanOptions, guild: Guild, user: User, model: Punishment) {
        this.channel(async (channel) => {
            let r = '*No reason provided*';

            const auditLog = (await guild.fetchAuditLogs({
                limit: 1,
                type: 'MEMBER_BAN_ADD',
            })).entries.first();         

            if (banOptions.reason) {
                r = banOptions.reason;
            }
            else if (auditLog) {
                console.log(auditLog);  
                const { target, reason } = await auditLog;

                if (target!.id === user.id && reason) {
                    r = await reason;
                }
            }

            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setTitle("A user was temporarily banned")
                    .setAuthor({
                        name: user.tag,
                        iconURL: user.displayAvatarURL(),
                    })
                    .addField('Reason', r)
                    .addField('Banned by', model.get().mod_tag)
                    .addField('User ID', user.id)
                    .addField('Duration', ms(model.get().meta?.time))
                    .setFooter({
                        text: "Temporarily banned",
                    })
                    .setTimestamp()
                ]
            });
        }, {
            guild
        });
    }

    logUnbanned(ban: GuildBan) {
        this.channel(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setTitle("A user was unbanned")
                    .setAuthor({
                        name: ban.user.tag,
                        iconURL: ban.user.displayAvatarURL(),
                    })
                    .addField('User ID', ban.user.id)
                    .setFooter({
                        text: "Unbanned",
                    })
                    .setTimestamp()
                ]
            });
        }, ban);
    }

    logJoined(member: GuildMember) {
        this.channelJoinLeft(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#007bff')
                    .setTitle("New member joined")
                    .setAuthor({
                        name: member.user.tag,
                        iconURL: member.user.displayAvatarURL(),
                    })
                    .setDescription(`<@${member.user.id}> just joined the server!`)
                    .addField('Account Created', `${member.user.createdAt.toLocaleString()} (${timeSince(member.user.createdAt.getTime())})`)
                    .addField('New Account?', (new Date().getTime() - member.user.createdAt.getTime()) <= 3 * 24 * 60 * 60 * 1000 ? ":warning: Yes :warning:" : "No")
                    .addField('Bot?', member.user.bot === true ? 'Yes' : 'No')
                    .addField('User ID', member.user.id)
                    .setFooter({
                        text: "Joined",
                    })
                    .setTimestamp()
                ]
            });
        }, member);
    }

    logLeft(member: GuildMember) {
        this.channelJoinLeft(async (channel) => {
            const roles = await member.roles.cache.filter(role => role.id !== member.guild.id).reduce((acc, val) => ` ${acc} ${roleMention(val.id)}`, '');

            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setTitle("Member left")
                    .setAuthor({
                        name: member.user.tag,
                        iconURL: member.user.displayAvatarURL(),
                    })
                    .setDescription(`**Roles**\n${roles}`)
                    .addField('Joined at', `${member.joinedAt!.toLocaleString()} (${timeSince(member.joinedAt!.getTime())})`)
                    .addField('User ID', member.user.id)
                    .addField('Bot?', member.user.bot === true ? 'Yes' : 'No')
                    .setFooter({
                        text: "Left",
                    })
                    .setTimestamp()
                ]
            });
        }, member);
    }

    logBeaned(member: GuildMember, r: string, d: User) {
        this.channel(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#007bff')
                    .setTitle("Member beaned")
                    .setAuthor({
                        name: member.user.tag,
                        iconURL: member.user.displayAvatarURL(),
                    })
                    .addField('Reason', r)
                    .addField('Beaned by', d.tag)
                    .addField('User ID', member.user.id)
                    .setFooter({
                        text: "Beaned",
                    })
                    .setTimestamp()
                ]
            });
        }, member);
    }

    logMute(member: GuildMember, reason: string, timeMs: number | null | undefined, d: User, hard: boolean = true) {
        this.channel(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setTitle("Member muted")
                    .setAuthor({
                        name: member.user.tag,
                        iconURL: member.user.displayAvatarURL(),
                    })
                    .addField('Reason', reason)
                    .addField('Muted by', d.tag)
                    .addField('Duration Until', typeof timeMs === 'number' ? `${new Date((timeMs / 1000) + Date.now()).toLocaleString()} (${timeProcess(timeMs / 1000)})` : "*No duration set*")
                    .addField('User ID', member.user.id)
                    .addField('Hardmute', hard ? 'Yes' : 'No')
                    .setFooter({
                        text: "Muted",
                    })
                    .setTimestamp()
                ]
            });
        }, member);
    }

    logUnmute(member: GuildMember, d: User) {
        this.channel(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('#007bff')
                    .setTitle("Member unmuted")
                    .setAuthor({
                        name: member.user.tag,
                        iconURL: member.user.displayAvatarURL(),
                    })
                    .addField('Unmuted by', d.tag)
                    .addField('User ID', member.user.id)
                    .setFooter({
                        text: "Unmuted",
                    })
                    .setTimestamp()
                ]
            });
        }, member);
    }

    logWarn(msg: Message | CommandInteraction, member: GuildMember | User, d: User, reason: string | undefined, id: number | string) {
        if ((member as GuildMember).user)
            member = (member as GuildMember).user;

        this.channel(async (channel) => {            
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('GOLD')
                    .setTitle("Member warned")
                    .setAuthor({
                        name: (member as User).tag,
                        iconURL: member.displayAvatarURL(),
                    })
                    .addField('Reason', reason ?? '*No reason provided*')
                    .addField('Warned by', d.tag)
                    .addField('User ID', member.id)
                    .addField('Case ID', id + '')
                    .setFooter({
                        text: "Warned",
                    })
                    .setTimestamp()
                ]
            });
        }, msg);
    }

    logWarndel(msg: Message, member: GuildMember, warn: any, d: User) {
        this.channel(async (channel) => {
            await channel.send({
                embeds: [
                    new MessageEmbed()
                    .setColor('GOLD')
                    .setTitle("Warning deleted")
                    .setAuthor({
                        name: member.user.tag,
                        iconURL: member.user.displayAvatarURL(),
                    })
                    .addField('Warned by', d.tag + '')
                    .addField('Warning ID', warn.id + '')
                    .addField('User ID', member.user.id)
                    .setFooter({
                        text: "Warning Deleted",
                    })
                    .setTimestamp()
                ]
            });
        }, msg);
    }
}

export default Logger;
1	rakinar2	577	import { roleMention } from '@discordjs/builders';
2			import { BanOptions, CommandInteraction, FileOptions, Guild, GuildBan, GuildMember, Message, MessageEmbed, MessageOptions, MessagePayload, TextChannel, User } from 'discord.js';
3			import ms from 'ms';
4			import DiscordClient from '../client/Client';
5			import Punishment from '../models/Punishment';
6			import { timeProcess, timeSince } from '../utils/util';
7
8			class Logger {
9			client: DiscordClient;
10
11			constructor(client: DiscordClient) {
12			this.client = client;
13			}
14
15			channel(callback: (channel: TextChannel) => any, msg: any) {
16			let channelID = this.client.config.props[msg.guild!.id].logging_channel;
17			let channel = msg.guild!.channels.cache.find((c: any) => c.id === channelID) as TextChannel;
18
19			if (channel) {
20			return callback(channel);
21			}
22			}
23
24			channelJoinLeft(callback: (channel: TextChannel) => any, msg: any) {
25			let channelID = this.client.config.props[msg.guild!.id].logging_channel_join_leave;
26			let channel = msg.guild!.channels.cache.find((c: any) => c.id === channelID) as TextChannel;
27
28			if (channel) {
29			return callback(channel);
30			}
31			}
32
33			async send(guild: Guild, messageOptions: MessageOptions \| MessagePayload \| string) {
34			let channelID = this.client.config.props[guild!.id].logging_channel;
35			let channel = guild!.channels.cache.find((c: any) => c.id === channelID) as TextChannel;
36
37			if (channel) {
38			return await channel.send(messageOptions);
39			}
40			}
41
42			log(guild: Guild, callback: (channel: TextChannel) => any) {
43			this.channel(callback, { guild });
44			}
45
46			logEdit(oldMsg: Message, newMsg: Message) {
47			this.channel(async (channel) => {
48			await channel.send({
49			embeds: [
50			new MessageEmbed()
51			.setColor('#007bff')
52			.setTitle('Message Edited in #' + (newMsg.channel as TextChannel).name + " (" + newMsg.channel.id + ")")
53			.setDescription('-+-+Before\n' + oldMsg.content + '\n\n-+-+After\n' + newMsg.content)
54			.addField('ID', newMsg.id)
55			.setAuthor({
56			name: newMsg.author.tag,
57			iconURL: newMsg.author.displayAvatarURL(),
58			})
59			.setFooter({
60			text: "Edited",
61			})
62			.setTimestamp()
63			]
64			});
65			}, newMsg);
66			}
67
68			logDelete(msg: Message) {
69			this.channel(async (channel) => {
70			const embed = new MessageEmbed()
71			.setColor('#f14a60')
72			.setTitle('Message Deleted in #' + (msg.channel as TextChannel).name + " (" + msg.channel.id + ")")
73			.setDescription(msg.content)
74			.setAuthor({
75			name: msg.author.tag,
76			iconURL: msg.author.displayAvatarURL(),
77			})
78			.addField('ID', msg.id)
79			.setFooter({
80			text: "Deleted",
81			})
82			.setTimestamp();
83
84			const files: FileOptions[] = [];
85
86			if (msg.attachments.size > 0) {
87			let str = '';
88
89			msg.attachments.forEach(a => {
90			str += `${a.name}\n`;
91			files.push({
92			name: a.name!,
93			attachment: a.proxyURL
94			});
95			});
96
97			embed.addField('Attachments (top)', str);
98			}
99
100			await channel.send({
101			embeds: [
102			embed
103			],
104			files
105			});
106			}, msg);
107			}
108
109			logBanned(ban: GuildBan) {
110			this.channel(async (channel) => {
111			let r = 'No reason provided';
112
113			const auditLog = (await ban.guild.fetchAuditLogs({
114			limit: 1,
115			type: 'MEMBER_BAN_ADD',
116			})).entries.first();
117
118
119			if (ban.reason) {
120			r = ban.reason;
121			}
122			else if (auditLog) {
123			console.log(auditLog);
124			const { target, reason } = await auditLog;
125
126			if (target!.id === ban.user.id && reason) {
127			r = await reason;
128			}
129			}
130
131			await channel.send({
132			embeds: [
133			new MessageEmbed()
134			.setColor('#f14a60')
135			.setTitle("A user was banned")
136			.setAuthor({
137			name: ban.user.tag,
138			iconURL: ban.user.displayAvatarURL(),
139			})
140			.addField('Reason', r)
141			.addField('User ID', ban.user.id)
142			.setFooter({
143			text: "Banned",
144			})
145			.setTimestamp()
146			]
147			});
148			}, ban);
149			}
150
151			logSoftBan(banOptions: BanOptions, guild: Guild, user: User, model: Punishment) {
152			this.channel(async (channel) => {
153			let r = 'No reason provided';
154
155			const auditLog = (await guild.fetchAuditLogs({
156			limit: 1,
157			type: 'MEMBER_BAN_ADD',
158			})).entries.first();
159
160			if (banOptions.reason) {
161			r = banOptions.reason;
162			}
163			else if (auditLog) {
164			console.log(auditLog);
165			const { target, reason } = await auditLog;
166
167			if (target!.id === user.id && reason) {
168			r = await reason;
169			}
170			}
171
172			await channel.send({
173			embeds: [
174			new MessageEmbed()
175			.setColor('#f14a60')
176			.setTitle("A user was softbanned")
177			.setAuthor({
178			name: user.tag,
179			iconURL: user.displayAvatarURL(),
180			})
181			.addField('Reason', r)
182			.addField('Softbanned by', model.get().mod_tag)
183			.addField('User ID', user.id)
184			.setFooter({
185			text: "Softbanned",
186			})
187			.setTimestamp()
188			]
189			});
190			}, {
191			guild
192			});
193			}
194
195			logTempBan(banOptions: BanOptions, guild: Guild, user: User, model: Punishment) {
196			this.channel(async (channel) => {
197			let r = 'No reason provided';
198
199			const auditLog = (await guild.fetchAuditLogs({
200			limit: 1,
201			type: 'MEMBER_BAN_ADD',
202			})).entries.first();
203
204			if (banOptions.reason) {
205			r = banOptions.reason;
206			}
207			else if (auditLog) {
208			console.log(auditLog);
209			const { target, reason } = await auditLog;
210
211			if (target!.id === user.id && reason) {
212			r = await reason;
213			}
214			}
215
216			await channel.send({
217			embeds: [
218			new MessageEmbed()
219			.setColor('#f14a60')
220			.setTitle("A user was temporarily banned")
221			.setAuthor({
222			name: user.tag,
223			iconURL: user.displayAvatarURL(),
224			})
225			.addField('Reason', r)
226			.addField('Banned by', model.get().mod_tag)
227			.addField('User ID', user.id)
228			.addField('Duration', ms(model.get().meta?.time))
229			.setFooter({
230			text: "Temporarily banned",
231			})
232			.setTimestamp()
233			]
234			});
235			}, {
236			guild
237			});
238			}
239
240			logUnbanned(ban: GuildBan) {
241			this.channel(async (channel) => {
242			await channel.send({
243			embeds: [
244			new MessageEmbed()
245			.setColor('#f14a60')
246			.setTitle("A user was unbanned")
247			.setAuthor({
248			name: ban.user.tag,
249			iconURL: ban.user.displayAvatarURL(),
250			})
251			.addField('User ID', ban.user.id)
252			.setFooter({
253			text: "Unbanned",
254			})
255			.setTimestamp()
256			]
257			});
258			}, ban);
259			}
260
261			logJoined(member: GuildMember) {
262			this.channelJoinLeft(async (channel) => {
263			await channel.send({
264			embeds: [
265			new MessageEmbed()
266			.setColor('#007bff')
267			.setTitle("New member joined")
268			.setAuthor({
269			name: member.user.tag,
270			iconURL: member.user.displayAvatarURL(),
271			})
272			.setDescription(`<@${member.user.id}> just joined the server!`)
273			.addField('Account Created', `${member.user.createdAt.toLocaleString()} (${timeSince(member.user.createdAt.getTime())})`)
274			.addField('New Account?', (new Date().getTime() - member.user.createdAt.getTime()) <= 3 * 24 * 60 * 60 * 1000 ? ":warning: Yes :warning:" : "No")
275			.addField('Bot?', member.user.bot === true ? 'Yes' : 'No')
276			.addField('User ID', member.user.id)
277			.setFooter({
278			text: "Joined",
279			})
280			.setTimestamp()
281			]
282			});
283			}, member);
284			}
285
286			logLeft(member: GuildMember) {
287			this.channelJoinLeft(async (channel) => {
288			const roles = await member.roles.cache.filter(role => role.id !== member.guild.id).reduce((acc, val) => ` ${acc} ${roleMention(val.id)}`, '');
289
290			await channel.send({
291			embeds: [
292			new MessageEmbed()
293			.setColor('#f14a60')
294			.setTitle("Member left")
295			.setAuthor({
296			name: member.user.tag,
297			iconURL: member.user.displayAvatarURL(),
298			})
299			.setDescription(`Roles\n${roles}`)
300			.addField('Joined at', `${member.joinedAt!.toLocaleString()} (${timeSince(member.joinedAt!.getTime())})`)
301			.addField('User ID', member.user.id)
302			.addField('Bot?', member.user.bot === true ? 'Yes' : 'No')
303			.setFooter({
304			text: "Left",
305			})
306			.setTimestamp()
307			]
308			});
309			}, member);
310			}
311
312			logBeaned(member: GuildMember, r: string, d: User) {
313			this.channel(async (channel) => {
314			await channel.send({
315			embeds: [
316			new MessageEmbed()
317			.setColor('#007bff')
318			.setTitle("Member beaned")
319			.setAuthor({
320			name: member.user.tag,
321			iconURL: member.user.displayAvatarURL(),
322			})
323			.addField('Reason', r)
324			.addField('Beaned by', d.tag)
325			.addField('User ID', member.user.id)
326			.setFooter({
327			text: "Beaned",
328			})
329			.setTimestamp()
330			]
331			});
332			}, member);
333			}
334
335			logMute(member: GuildMember, reason: string, timeMs: number \| null \| undefined, d: User, hard: boolean = true) {
336			this.channel(async (channel) => {
337			await channel.send({
338			embeds: [
339			new MessageEmbed()
340			.setColor('#f14a60')
341			.setTitle("Member muted")
342			.setAuthor({
343			name: member.user.tag,
344			iconURL: member.user.displayAvatarURL(),
345			})
346			.addField('Reason', reason)
347			.addField('Muted by', d.tag)
348			.addField('Duration Until', typeof timeMs === 'number' ? `${new Date((timeMs / 1000) + Date.now()).toLocaleString()} (${timeProcess(timeMs / 1000)})` : "No duration set")
349			.addField('User ID', member.user.id)
350			.addField('Hardmute', hard ? 'Yes' : 'No')
351			.setFooter({
352			text: "Muted",
353			})
354			.setTimestamp()
355			]
356			});
357			}, member);
358			}
359
360			logUnmute(member: GuildMember, d: User) {
361			this.channel(async (channel) => {
362			await channel.send({
363			embeds: [
364			new MessageEmbed()
365			.setColor('#007bff')
366			.setTitle("Member unmuted")
367			.setAuthor({
368			name: member.user.tag,
369			iconURL: member.user.displayAvatarURL(),
370			})
371			.addField('Unmuted by', d.tag)
372			.addField('User ID', member.user.id)
373			.setFooter({
374			text: "Unmuted",
375			})
376			.setTimestamp()
377			]
378			});
379			}, member);
380			}
381
382			logWarn(msg: Message \| CommandInteraction, member: GuildMember \| User, d: User, reason: string \| undefined, id: number \| string) {
383			if ((member as GuildMember).user)
384			member = (member as GuildMember).user;
385
386			this.channel(async (channel) => {
387			await channel.send({
388			embeds: [
389			new MessageEmbed()
390			.setColor('GOLD')
391			.setTitle("Member warned")
392			.setAuthor({
393			name: (member as User).tag,
394			iconURL: member.displayAvatarURL(),
395			})
396			.addField('Reason', reason ?? 'No reason provided')
397			.addField('Warned by', d.tag)
398			.addField('User ID', member.id)
399			.addField('Case ID', id + '')
400			.setFooter({
401			text: "Warned",
402			})
403			.setTimestamp()
404			]
405			});
406			}, msg);
407			}
408
409			logWarndel(msg: Message, member: GuildMember, warn: any, d: User) {
410			this.channel(async (channel) => {
411			await channel.send({
412			embeds: [
413			new MessageEmbed()
414			.setColor('GOLD')
415			.setTitle("Warning deleted")
416			.setAuthor({
417			name: member.user.tag,
418			iconURL: member.user.displayAvatarURL(),
419			})
420			.addField('Warned by', d.tag + '')
421			.addField('Warning ID', warn.id + '')
422			.addField('User ID', member.user.id)
423			.setFooter({
424			text: "Warning Deleted",
425			})
426			.setTimestamp()
427			]
428			});
429			}, msg);
430			}
431			}
432
433			export default Logger;