<ref *1> ExtendedClient {
  _events: [Object: null prototype] {
    shardDisconnect: [Function (anonymous)],
    ready: [ [Function (anonymous)], [AsyncFunction (anonymous)] ],
    interactionCreate: [ [AsyncFunction (anonymous)], [AsyncFunction (anonymous)] ],
    error: [Function (anonymous)],
    guildCreate: [AsyncFunction (anonymous)],
    guildMemberAdd: [AsyncFunction (anonymous)],
    messageCreate: [AsyncFunction (anonymous)]
  },
  _eventsCount: 7,
  _maxListeners: undefined,
  options: {
    intents: IntentsBitField { bitfield: 4675 },
    partials: [ 1, 2, 5, 3, 4, 0 ],
    allowedMentions: { repliedUser: false, parse: [Array] },
    makeCache: [Function (anonymous)],
    closeTimeout: 5000,
    waitGuildTimeout: 15000,
    shardCount: 1,
    failIfNotExists: true,
    presence: { status: 'online', user: [Object] },
    sweepers: { threads: [Object] },
    ws: {
      large_threshold: 50,
      compress: false,
      properties: [Object],
      version: 10,
      presence: [Object]
    },
    rest: {
      agent: [Getter],
      api: 'https://discord.com/api',
      authPrefix: 'Bot',
      cdn: 'https://cdn.discordapp.com',
      headers: {},
      invalidRequestWarningInterval: 0,
      globalRequestsPerSecond: 50,
      offset: 50,
      rejectOnRateLimit: null,
      retries: 3,
      timeout: 15000,
      userAgentAppendix: 'Node.js v19.5.0',
      version: '10',
      hashSweepInterval: 14400000,
      hashLifetime: 86400000,
      handlerSweepInterval: 3600000
    },
    jsonTransformer: [Function: toSnakeCase],
    shards: [ 0 ]
  },
  rest: REST {
    _events: [Object: null prototype] {
      newListener: [Function (anonymous)],
      removeListener: [Function (anonymous)]
    },
    _eventsCount: 2,
    _maxListeners: undefined,
    cdn: CDN { base: 'https://cdn.discordapp.com' },
    requestManager: RequestManager {
      _events: [Object: null prototype],
      _eventsCount: 4,
      _maxListeners: undefined,
      agent: [Agent],
      globalDelay: null,
      globalReset: 1678970435862,
      hashes: [Collection [Map]],
      handlers: [Collection [Map]],
      options: [Object],
      globalRemaining: 49,
      hashTimer: Timeout {
        _idleTimeout: 14400000,
        _idlePrev: [TimersList],
        _idleNext: [TimersList],
        _idleStart: 43201058,
        _onTimeout: [Function (anonymous)],
        _timerArgs: undefined,
        _repeat: 14400000,
        _destroyed: false,
        [Symbol(refed)]: false,
        [Symbol(kHasPrimitive)]: false,
        [Symbol(asyncId)]: 32,
        [Symbol(triggerId)]: 1
      },
      handlerTimer: Timeout {
        _idleTimeout: 3600000,
        _idlePrev: [Timeout],
        _idleNext: [TimersList],
        _idleStart: 50401095,
        _onTimeout: [Function (anonymous)],
        _timerArgs: undefined,
        _repeat: 3600000,
        _destroyed: false,
        [Symbol(refed)]: false,
        [Symbol(kHasPrimitive)]: false,
        [Symbol(asyncId)]: 33,
        [Symbol(triggerId)]: 1
      },
      [Symbol(kCapture)]: false
    },
    [Symbol(kCapture)]: false
  },
  ws: WebSocketManager {
    _events: [Object: null prototype] {},
    _eventsCount: 0,
    _maxListeners: undefined,
    gateway: 'wss://gateway.discord.gg/',
    totalShards: 1,
    shards: Collection(1) [Map] { 0 => [WebSocketShard] },
    status: 0,
    destroyed: false,
    reconnecting: false,
    [Symbol(kCapture)]: false
  },
  actions: ActionsManager {
    injectedUser: Symbol(djs.actions.injectedUser),
    injectedChannel: Symbol(djs.actions.injectedChannel),
    injectedMessage: Symbol(djs.actions.injectedMessage),
    client: [Circular *1],
    ApplicationCommandPermissionsUpdate: ApplicationCommandPermissionsUpdateAction { client: [Circular *1] },
    AutoModerationActionExecution: AutoModerationActionExecutionAction { client: [Circular *1] },
    AutoModerationRuleCreate: AutoModerationRuleCreateAction { client: [Circular *1] },
    AutoModerationRuleDelete: AutoModerationRuleDeleteAction { client: [Circular *1] },
    AutoModerationRuleUpdate: AutoModerationRuleUpdateAction { client: [Circular *1] },
    ChannelCreate: ChannelCreateAction { client: [Circular *1] },
    ChannelDelete: ChannelDeleteAction { client: [Circular *1] },
    ChannelUpdate: ChannelUpdateAction { client: [Circular *1] },
    GuildAuditLogEntryCreate: GuildAuditLogEntryCreateAction { client: [Circular *1] },
    GuildBanAdd: GuildBanAdd { client: [Circular *1] },
    GuildBanRemove: GuildBanRemove { client: [Circular *1] },
    GuildChannelsPositionUpdate: GuildChannelsPositionUpdate { client: [Circular *1] },
    GuildDelete: GuildDeleteAction { client: [Circular *1] },
    GuildEmojiCreate: GuildEmojiCreateAction { client: [Circular *1] },
    GuildEmojiDelete: GuildEmojiDeleteAction { client: [Circular *1] },
    GuildEmojiUpdate: GuildEmojiUpdateAction { client: [Circular *1] },
    GuildEmojisUpdate: GuildEmojisUpdateAction { client: [Circular *1] },
    GuildIntegrationsUpdate: GuildIntegrationsUpdate { client: [Circular *1] },
    GuildMemberRemove: GuildMemberRemoveAction { client: [Circular *1] },
    GuildMemberUpdate: GuildMemberUpdateAction { client: [Circular *1] },
    GuildRoleCreate: GuildRoleCreate { client: [Circular *1] },
    GuildRoleDelete: GuildRoleDeleteAction { client: [Circular *1] },
    GuildRoleUpdate: GuildRoleUpdateAction { client: [Circular *1] },
    GuildRolesPositionUpdate: GuildRolesPositionUpdate { client: [Circular *1] },
    GuildScheduledEventCreate: GuildScheduledEventCreateAction { client: [Circular *1] },
    GuildScheduledEventDelete: GuildScheduledEventDeleteAction { client: [Circular *1] },
    GuildScheduledEventUpdate: GuildScheduledEventUpdateAction { client: [Circular *1] },
    GuildScheduledEventUserAdd: GuildScheduledEventUserAddAction { client: [Circular *1] },
    GuildScheduledEventUserRemove: GuildScheduledEventUserRemoveAction { client: [Circular *1] },
    GuildStickerCreate: GuildStickerCreateAction { client: [Circular *1] },
    GuildStickerDelete: GuildStickerDeleteAction { client: [Circular *1] },
    GuildStickerUpdate: GuildStickerUpdateAction { client: [Circular *1] },
    GuildStickersUpdate: GuildStickersUpdateAction { client: [Circular *1] },
    GuildUpdate: GuildUpdateAction { client: [Circular *1] },
    InteractionCreate: InteractionCreateAction { client: [Circular *1] },
    InviteCreate: InviteCreateAction { client: [Circular *1] },
    InviteDelete: InviteDeleteAction { client: [Circular *1] },
    MessageCreate: MessageCreateAction { client: [Circular *1] },
    MessageDelete: MessageDeleteAction { client: [Circular *1] },
    MessageDeleteBulk: MessageDeleteBulkAction { client: [Circular *1] },
    MessageReactionAdd: MessageReactionAdd { client: [Circular *1] },
    MessageReactionRemove: MessageReactionRemove { client: [Circular *1] },
    MessageReactionRemoveAll: MessageReactionRemoveAll { client: [Circular *1] },
    MessageReactionRemoveEmoji: MessageReactionRemoveEmoji { client: [Circular *1] },
    MessageUpdate: MessageUpdateAction { client: [Circular *1] },
    PresenceUpdate: PresenceUpdateAction { client: [Circular *1] },
    StageInstanceCreate: StageInstanceCreateAction { client: [Circular *1] },
    StageInstanceDelete: StageInstanceDeleteAction { client: [Circular *1] },
    StageInstanceUpdate: StageInstanceUpdateAction { client: [Circular *1] },
    ThreadCreate: ThreadCreateAction { client: [Circular *1] },
    ThreadDelete: ThreadDeleteAction { client: [Circular *1] },
    ThreadListSync: ThreadListSyncAction { client: [Circular *1] },
    ThreadMemberUpdate: ThreadMemberUpdateAction { client: [Circular *1] },
    ThreadMembersUpdate: ThreadMembersUpdateAction { client: [Circular *1] },
    TypingStart: TypingStart { client: [Circular *1] },
    UserUpdate: UserUpdateAction { client: [Circular *1] },
    VoiceStateUpdate: VoiceStateUpdate { client: [Circular *1] },
    WebhooksUpdate: WebhooksUpdate { client: [Circular *1] }
  },
  voice: ClientVoiceManager { adapters: Map(0) {} },
  shard: null,
  users: UserManager {},
  guilds: GuildManager {},
  channels: ChannelManager {},
  sweepers: Sweepers {
    options: { threads: [Object] },
    intervals: {
      autoModerationRules: null,
      applicationCommands: null,
      bans: null,
      emojis: null,
      invites: null,
      guildMembers: null,
      messages: null,
      presences: null,
      reactions: null,
      stageInstances: null,
      stickers: null,
      threadMembers: null,
      threads: Timeout {
        _idleTimeout: 3600000,
        _idlePrev: [TimersList],
        _idleNext: [Timeout],
        _idleStart: 50401110,
        _onTimeout: [Function (anonymous)],
        _timerArgs: undefined,
        _repeat: 3600000,
        _destroyed: false,
        [Symbol(refed)]: false,
        [Symbol(kHasPrimitive)]: false,
        [Symbol(asyncId)]: 34,
        [Symbol(triggerId)]: 1
      },
      users: null,
      voiceStates: null
    }
  },
  presence: ClientPresence {
    userId: null,
    guild: null,
    status: 'online',
    activities: [ [Activity] ],
    clientStatus: null
  },
  user: ClientUser {
    id: '966867846636392458',
    bot: true,
    system: false,
    flags: UserFlagsBitField { bitfield: 524288 },
    username: 'Fuego',
    discriminator: '5740',
    avatar: '21e1f74921a79a5fb24ec620210af41f',
    banner: undefined,
    accentColor: undefined,
    verified: true,
    mfaEnabled: true
  },
  application: ClientApplication {
    id: '966867846636392458',
    name: null,
    description: null,
    icon: null,
    tags: [],
    installParams: null,
    customInstallURL: null,
    flags: ApplicationFlagsBitField { bitfield: 27295744 },
    cover: null,
    rpcOrigins: [],
    botRequireCodeGrant: null,
    botPublic: null,
    roleConnectionsVerificationURL: null,
    owner: null,
    commands: ApplicationCommandManager {
      permissions: [ApplicationCommandPermissionsManager]
    }
  },
  readyTimestamp: 1678918515668,
  stickyCache: Collection(1) [Map] {
    '1077275626655981651' => {
      channelId: '1077275626655981651',
      content: 'he likes good girls',
      messageId: '1084594064890007605'
    }
  },
  chatCommands: Collection(12) [Map] {
    'botconfig' => CICommand {
      name: 'botconfig',
      description: 'Configure the bot for use in your server!',
      extendedDescription: 'The </botconfig:CommandId> command is the first command a server admin should check after adding Fuego to their server\n' +
        '\n' +
        "With access to all of the per-server settings, you can tailor some of her features to your community and it's needs.\n" +
        'This includes setting up the role to use when dunking members, the channel to store moderation logs and more!',
      emoji: '📋',
      options: [Array],
      category: 'config',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    },
    'balance' => CICommand {
      name: 'balance',
      description: 'Check yours or someones balance!',
      emoji: '💵',
      options: [Array],
      category: 'currency',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    'deposit' => CICommand {
      name: 'deposit',
      description: 'Deposit coins in to your vault.',
      extendedDescription: 'The idea of having all your coin in your pockets getting you down?\n' +
        "Worry not, use the </deposit:CommandId> command to put it safely away in your vault. I'm sure it's *totally* safe there right? 👀",
      emoji: '👇',
      options: [Array],
      category: 'currency',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    'gift' => CICommand {
      name: 'gift',
      description: 'Gift coins and items to other members!',
      extendedDescription: 'Feeling generous? Got the urge to give away some of your own hard earned items to your fellow server members?\n' +
        "We like philanthropy here too, so if you're in the giving mood We have you covered!\n" +
        '\n' +
        'Use </gift coins:CommandId> to give away coins to people, limited of course by what you have yourself to give.\n' +
        "Alternatively, check out </gift items:CommandId> if it's items you're desperate to give away...",
      emoji: '🫴',
      options: [Array],
      category: 'currency',
      dmPermission: false,
      run: [AsyncFunction: run]
    },
    'withdraw' => CICommand {
      name: 'withdraw',
      description: 'Withdraw coins from your vault.',
      extendedDescription: 'Sometimes you just need to flex how much coin you have. When that happens, use the </withdraw:CommandId> command to really flex on the haters.',
      emoji: '👆',
      options: [Array],
      category: 'currency',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    '8ball' => CICommand {
      name: '8ball',
      description: 'Why make grown up decisions when the Magic 8Ball can do it for you?',
      emoji: '🎱',
      options: [Array],
      category: 'fun',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    'image' => CICommand {
      name: 'image',
      description: 'Generate an image from a number of options.',
      emoji: '🌃',
      options: [Array],
      category: 'fun',
      run: [AsyncFunction: run]
    },
    'invite' => CICommand {
      name: 'invite',
      description: 'Provide instructions on how to add me to your own server!',
      extendedDescription: 'Sharing is caring, and we think you should totally share Fuego with your friends!\n' +
        'Use the </invite:CommandId> command to add her to another server of your choosing.',
      emoji: '📮',
      category: 'system',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    'ping' => CICommand {
      name: 'ping',
      description: 'Measure the Fuego <-> Discord latency.',
      extendedDescription: 'Not much can be said about the </ping:CommandId>, it was originally only intended to help with development.\n' +
        "It was Fuego's first command and has persisted throughout all of her development cycles!",
      emoji: '🏓',
      category: 'system',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    'help' => CICommand {
      name: 'help',
      description: 'Learn how to use Fuego.',
      extendedDescription: 'The /help command is the perfect starting point for new users of Fuego who want to know what she can do\n' +
        '\n' +
        '</help about:CommandId> will show you basic information about Fuego and the technologies that power her.\n' +
        'While </help commands:CommandId> can be used to either show a brief breakdown of all of her commands, or supplied a command name to see information about a single specific command!',
      emoji: '🤔',
      options: [Array],
      category: 'user',
      run: [AsyncFunction: run]
    },
    'shorten' => CICommand {
      name: 'shorten',
      description: 'Quick and easy URL shortener, right here in Discord.',
      extendedDescription: 'Nobody likes long and complicated URLs, and who wants to click on a link with tens of numbers and letters for something trivial?\n' +
        'Yeah, we hate them too. So we created a very simple URL shortener. Check it out with the </shorten:CommandId>\n' +
        '\n' +
        'No facy referral redirecting, no tracking, no logging of clicks. Just simple redirection to make even your ugliest links look pretty - all using our own a0.wtf domain.',
      emoji: '🪚',
      options: [Array],
      category: 'utility',
      dmPermission: true,
      run: [AsyncFunction: run]
    },
    'sticky' => CICommand {
      name: 'sticky',
      description: 'Manage sticky messages.',
      extendedDescription: "Ever have the feeling that people just don't read a channels pinned messages?\n" +
        "That's because actually, a lot of people don't. But don't let the obscurity of them let you down, we have you covered.\n" +
        '\n' +
        'You can use the </sticky add:CommandId> command to setup, and edit, a stuck message in a channel. That sticky message becomes persistent, always showing as the latest message in a channel!\n' +
        '\n' +
        "Alternatively, if you need to remove a sticky message from a channel... well, it's probably obvious then what </sticky remove:CommandId> does...",
      emoji: '📌',
      options: [Array],
      category: 'utility',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    }
  },
  ctxCommands: Collection(2) [Map] {
    'Dunk Member' => UserCtxCommand {
      name: 'Dunk Member',
      extendedDescription: 'Sometimes you just need to remove certain people from certain situations.\n' +
        "That's where Dunking comes in. With a click of a button, or a tap of the screen, you can temporarily remove a member from interacting with the rest of the server. Giving you a chance to take control of bad situations.",
      emoji: '🚽',
      type: 2,
      category: 'moderation',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    },
    'Translate Message' => MessageCtxCommand {
      name: 'Translate Message',
      extendedDescription: 'What did they just call you?!\n' +
        'Right click a message, or tap and hold it on mobile, and find out with the Translate Message context menu command.',
      emoji: '🌍',
      type: 3,
      category: 'utility',
      dmPermission: false,
      run: [AsyncFunction: run]
    }
  },
  devCommands: Collection(4) [Map] {
    'award' => CICommand {
      name: 'award',
      description: 'Award coins and items to members.',
      emoji: '💳',
      options: [Array],
      category: 'dev',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    },
    'eval' => CICommand {
      name: 'eval',
      description: 'Evaluate code directly.',
      emoji: '🔧',
      options: [Array],
      category: 'dev',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    },
    'Evaluate Content' => MessageCtxCommand {
      name: 'Evaluate Content',
      emoji: '🔧',
      type: 3,
      category: 'dev',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    },
    'status' => CICommand {
      name: 'status',
      description: 'Set the status of the bot!',
      emoji: ':woman_getting_haircut:',
      options: [Array],
      category: 'dev',
      defaultMemberPermissions: '0',
      dmPermission: false,
      run: [AsyncFunction: run]
    }
  },
  cmdCategories: Set(7) {
    'config',
    'currency',
    'fun',
    'system',
    'user',
    'utility',
    'moderation'
  },
  logger: <ref *2> DerivedLogger {
    _readableState: ReadableState {
      objectMode: true,
      highWaterMark: 16,
      buffer: BufferList { head: null, tail: null, length: 0 },
      length: 0,
      pipes: [Array],
      pipesCount: 5,
      flowing: true,
      ended: false,
      endEmitted: false,
      reading: true,
      sync: false,
      needReadable: true,
      emittedReadable: false,
      readableListening: false,
      resumeScheduled: false,
      paused: false,
      emitClose: true,
      autoDestroy: false,
      destroyed: false,
      defaultEncoding: 'utf8',
      awaitDrain: 0,
      readingMore: false,
      decoder: null,
      encoding: null
    },
    readable: true,
    _events: [Object: null prototype] {
      prefinish: [Function: prefinish],
      end: [Array],
      data: [Array]
    },
    _eventsCount: 3,
    _maxListeners: undefined,
    _writableState: WritableState {
      objectMode: true,
      highWaterMark: 16,
      finalCalled: false,
      needDrain: false,
      ending: false,
      ended: false,
      finished: false,
      destroyed: false,
      decodeStrings: true,
      defaultEncoding: 'utf8',
      length: 0,
      writing: false,
      corked: 0,
      sync: false,
      bufferProcessing: false,
      onwrite: [Function (anonymous)],
      writecb: null,
      writelen: 0,
      bufferedRequest: null,
      lastBufferedRequest: null,
      pendingcb: 0,
      prefinished: false,
      errorEmitted: false,
      emitClose: true,
      autoDestroy: false,
      bufferedRequestCount: 0,
      corkedRequestsFree: [CorkedRequest]
    },
    writable: true,
    allowHalfOpen: true,
    _transformState: {
      afterTransform: [Function: bound afterTransform],
      needTransform: true,
      transforming: false,
      writecb: null,
      writechunk: null,
      writeencoding: 'utf8'
    },
    silent: undefined,
    format: Format { options: {}, Format: [Function: Format] },
    defaultMeta: null,
    levels: { error: 0, warn: 1, info: 2, debug: 3, meta: 4 },
    level: 'info',
    exceptions: ExceptionHandler { logger: [Circular *2], handlers: Map(0) {} },
    rejections: RejectionHandler { logger: [Circular *2], handlers: Map(0) {} },
    profilers: {},
    exitOnError: true,
    [Symbol(kCapture)]: false
  },
  [Symbol(kCapture)]: true
}