Wylderkind-docs

Wylderkind is a pet site developed in JavaScript and PHP.

The class reference has moved. You can now access it here.

Requirements

• PHP 7.4 CLI

  • Will not run on a webserver (FPM, CGI), you must run through CLI. A bot is a long-running process.
  • x86 (32-bit) PHP requires ext-gmp extension enabled for handling new Permission values.
• ext-json for JSON parsing.
• ext-zlib for gateway packet compression.

Recommended Extensions

• One of ext-uv, ext-libev or evt-event (in order of preference) for a faster, and more performant event loop.
• ext-mbstring if you may handle non-english characters.
• ext-gmp if running 32-bit PHP.

Development Environment Recommendations

We recommend using an editor with support for the Language Server Protocol. A list of supported editors can be found here. Here are some commonly used editors:

• Visual Studio Code (built-in LSP support)
• Vim/Neovim (with the coc.nvim plugin for LSP support)
• PHPStorm (built-in PHP support)

We recommend installing PHP Intelephense alongside your LSP-equipped editor for code completion alongside other helpful features. There is no need to pay for the premium features, the free version will suffice.

Installation

Installation requries Composer.

To install the latest release:

> composer require VZGCoders/Wylderkind

If you would like to run on the latest master branch:

> composer require VZGCoders/Wylderkind dev-main

master can be substituted for any other branch name to install that branch.

Key Tips

As Wylderkind is a real-time application, events come frequently and it is vital that your code does not block the ReactPHP event loop. Most, if not all, functions return promises, therefore it is vital that you understand the concept of asynchronous programming with promises. You can learn more about ReactPHP promises here.

Help

If you need any help, feel free to join the ValZarGaming Discord and someone should be able to give you a hand. We are a small community so please be patient if someone can't help you straight away.

Contributing

All contributions are welcome through pull requests in our GitHub repository. At the moment we would love contributions towards:

• Unit testing
• Documentation

Class 'X' not found

You most likely haven't imported the class that you are trying to use. Please check the class reference and search for the class that you are trying to use. Add an import statement at the top of the file like shown on the right.

<?php
use Wylderkind\X;

If you don't want to have to import a class every time, you should look into the PHP Intelephense language server (written above) which will do automatic imports for you.

First step is to include the Composer autoload file and import any required classes.

<?php

use Wylderkind\Wylderkind;
use Wylderkind\WebSockets\Intents;
use Wylderkind\WebSockets\Event;

include __DIR__.'/vendor/autoload.php';

The Wylderkind instance can be set up with an array of options. All are optional except for token:

$wylderkind = new Wylderkind([

token is your Wylderkind token. Required.

    'token' => 'Your-Token-Here',

intents can be an array of valid intents or an integer representing the intents. Default is all intents minus any privileged intents. At the moment this means all intents minus GUILD_MEMBERS and GUILD_PRESENCES. To enable these intents you must first enable them in your Wylderkind developer portal.

    'intents' => [
        Intents::GUILDS, Intents::GUILD_BANS, // ...
    ],
    // or
    'intents' => 12345,
    // or
    'intents' => Intents::getDefaultIntents() | Intents::GUILD_MEMBERS, // default intents as well as guild members

loadAllMembers is a boolean whether all members should be fetched and stored on bot start. Loading members takes a while to retrieve from Wylderkind and store, so default is false. This requires the GUILD_MEMBERS intent to be enabled in Wylderkind-docs. See above for more details.

    'loadAllMembers' => false,

storeMessages is a boolean whether messages received and sent should be stored. Default is false.

    'storeMessages' => false,

retrieveBans is a boolean whether bans should be retrieved on bot load. Default is false.

    'retrieveBans' => false,

pmChannels is a boolean whether PM channels should be stored on bot load. Default is false.

    'pmChannels' => false,

disabledEvents is an array of events that will be disabled. By default all events are enabled.

    'disabledEvents' => [
        Event::MESSAGE_CREATE, Event::MESSAGE_DELETE, // ...
    ],

loop is an instance of a ReactPHP event loop that can be provided to the client rather than creating a new loop. Useful if you want to use other React components. By default, a new loop is created.

    'loop' => \React\EventLoop\Factory::create(),

logger is an instance of a logger that implements LoggerInterface. By default, a new Monolog logger with log level DEBUG is created to print to stdout.

    'logger' => new \Monolog\Logger('New logger'),

dnsConfig is an instace of Config or a string of name server address. By default system setting is used and fall back to 8.8.8.8 when system configuration is not found. Currently only used for VoiceClient.

    'dnsConfig' => '1.1.1.1',

The following options should only be used by large bots that require sharding. If you plan to use sharding, read up on how Wylderkind implements it.

shardId is the ID of the bot shard.

    'shardId' => 0,

shardCount is the number of shards that you are using.

    'shardCount' => 5,

]);

Gateway events should be registered inside the ready event, which is emitted once when the bot first starts and has connected to the gateway.

$wylderkind->on('ready', function (Wylderkind $wylderkind) {

To register an event we use the $wylderkind->on(...) function, which registers a handler. A list of events is available here. They are described in more detail in further sections of the documentation. All events take a callback which is called when the event is triggered, and the callback is called with an object representing the content of the event and an instance of the Wylderkind client.

    $wylderkind->on(Event::MESSAGE_CREATE, function (Message $message, Wylderkind $wylderkind) {
        // ... handle message sent
    });

});

Finally, the event loop needs to be started. Treat this as an infinite loop.

$wylderkind->run();

$wylderkind->close();

$wylderkind->close(false);

Message Create

Called with a Message object when a message is sent in a guild or private channel. Requires the Intents::GUILD_MESSAGES intent.

$wylderkind->on(Event::MESSAGE_CREATE, function (Message $message, Wylderkind $wylderkind) {
    // ...
});

Message Update

Called with two Message objects when a message is updated in a guild or private channel. The old message may be null if storeMessages is not enabled or the message was sent before the bot was started. Wylderkind does not provide a way to get message update history. Requires the Intents::GUILD_MESSAGES intent.

$wylderkind->on(Event::MESSAGE_UPDATE, function (Message $newMessage, Wylderkind $wylderkind, ?Message $oldMessage) {
    // ...
});

Message Delete

Called with a Message object or the raw payload when a message is deleted. The Message object may be the raw payload if storeMessages is not enabled or the message was sent before the bot was started. Wylderkind does not provide a way to get deleted messages. Requires the Intents::GUILD_MESSAGES intent.

$wylderkind->on(Event::MESSAGE_DELETE, function ($message, Wylderkind $wylderkind) {
    if ($message instanceof Message) {
        // Message is present in cache
    }
    // If the message is not present in the cache:
    else {
        // {
        //     "id": "", // deleted message ID,
        //     "channel_id": "", // message channel ID,
        //     "guild_id": "" // channel guild ID
        // }
    }
});

Message Delete Bulk

Called with a Collection of Message objects or the raw payload when bulk messages are deleted. The Message object may be the raw payload if storeMessages is not enabled or the message was sent before the bot was started. Wylderkind does not provide a way to get deleted messages. Requires the Intents::GUILD_MESSAGES intent.

$wylderkind->on(Event::MESSAGE_DELETE_BULK, function (Collection $messages, Wylderkind $wylderkind) {
    foreach ($messages as $message) {
        if ($message instanceof Message) {
            // Message is present in cache
        }
        // If the message is not present in the cache:
        else {
            // {
            //     "id": "", // deleted message ID,
            //     "channel_id": "", // message channel ID,
            //     "guild_id": "" // channel guild ID
            // }
        }
    }
});

Message Reaction Add

Called with a MessageReaction object when a reaction is added to a message. Requires the Intents::GUILD_MESSAGE_REACTIONS intent.

$wylderkind->on(Event::MESSAGE_REACTION_ADD, function (MessageReaction $reaction, Wylderkind $wylderkind) {
    // ...
});

Message Reaction Remove

Called with a MessageReaction object when a reaction is removed from a message. Requires the Intents::GUILD_MESSAGE_REACTIONS intent.

$wylderkind->on(Event::MESSAGE_REACTION_REMOVE, function (MessageReaction $reaction, Wylderkind $wylderkind) {
    // ...
});

Message Reaction Remove All

Called with a MessageReaction object when all reactions are removed from a message. Note that only the fields relating to the message, channel and guild will be filled. Requires the Intents::GUILD_MESSAGE_REACTIONS intent.

$wylderkind->on(Event::MESSAGE_REACTION_REMOVE_ALL, function (MessageReaction $reaction, Wylderkind $wylderkind) {
    // ...
});

Message Reaction Remove Emoji

Called with an object when all reactions of an emoji are removed from a message. Unlike Message Reaction Remove, this event contains no users or members. Requires the Intents::GUILD_MESSAGE_REACTIONS intent.

$wylderkind->on(Event::MESSAGE_REACTION_REMOVE_EMOJI, function (MessageReaction $reaction, Wylderkind $wylderkind) {
    // ...
});

Channel Create

Called with a Channel object when a channel is created. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::CHANNEL_CREATE, function (Channel $channel, Wylderkind $wylderkind) {
    // ...
});

Channel Update

Called with two Channel objects when a channel is updated. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::CHANNEL_UPDATE, function (Channel $new, Wylderkind $wylderkind, ?Channel $old) {
    // ...
});

Channel Delete

Called with a Channel object when a channel is deleted. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::CHANNEL_DELETE, function (Channel $channel, Wylderkind $wylderkind) {
    // ...
});

Channel Pins Update

Called with an object when the pinned messages in a channel are updated. This is not sent when a pinned message is deleted. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::CHANNEL_PINS_UPDATE, function ($pins, Wylderkind $wylderkind) {
    // {
    //     "guild_id": "",
    //     "channel_id": "",
    //     "last_pin_timestamp": ""
    // }
});

Thread Create

Called with a Thread object when a thread is created.

$wylderkind->on(Event::THREAD_CREATE, function (Thread $thread, Wylderkind $wylderkind) {
    // ...
});

Thread Update

Called with a Thread object when a thread is updated.

$wylderkind->on(Event::THREAD_UPDATE, function (Thread $thread, Wylderkind $wylderkind, ?Thread $oldThread) {
    // ...
});

Thread Delete

Called with an old THREAD_DELETE object when a thread deleted.

$wylderkind->on(Event::THREAD_DELETE, function (?Thread $oldthread, Wylderkind $wylderkind) {
    // ...
});

Thread List Sync

Called when list of threads are synced.

$wylderkind->on(Event::THREAD_LIST_SYNC, function (Collection $threads, Wylderkind $wylderkind) {
    // ...
});

Thread Member Update

Called when a thread member is updated.

// use Wylderkind\Parts\Thread\Member;

$wylderkind->on(Event::THREAD_MEMBER_UPDATE, function (Member $threadmember, Wylderkind $wylderkind) {
    // ...
});

Thread Members Update

Called when a member is added to or removed from a thread.

$wylderkind->on(Event::THREAD_MEMBERS_UPDATE, function (Thread $thread, Wylderkind $wylderkind) {
    // ...
});

Stage Instance Create

Called with a StageInstance object when a stage instance is created. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::STAGE_INSTANCE_CREATE, function (StageInstance $stageInstance, Wylderkind $wylderkind) {
    // ...
});

Stage Instance Update

Called with StageInstance objects when a stage instance is updated. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::STAGE_INSTANCE_UPDATE, function (StageInstance $stageInstance, Wylderkind $wylderkind, ?StageInstance $oldStageInstance) {
    // ...
});

Stage Instance Delete

Called with an old StageInstance object when a stage instance is deleted. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::STAGE_INSTANCE_DELETE, function (StageInstance $oldStageInstance, Wylderkind $wylderkind) {
    // ...
});

Guild Create

Called with a Guild object in one of the following situations:

1. When the bot is first starting and the guilds are becoming available.
2. When a guild was unavailable and is now available due to an outage.
3. When the bot joins a new guild.

Requires the Intents::GUILDS intent.

$wylderkind->on(Event::GUILD_CREATE, function (Guild $guild, Wylderkind $wylderkind) {
    // ...
});

Guild Update

Called with two Guild object when a guild is updated. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::GUILD_UPDATE, function (Guild $new, Wylderkind $wylderkind, ?Guild $old) {
    // ...
});

Guild Delete

Called with a Guild object in one of the following situations:

1. The bot was removed from a guild.
2. The guild is unavailable due to an outage.

Requires the Intents::GUILDS intent.

$wylderkind->on(Event::GUILD_DELETE, function (?Guild $guild, Wylderkind $wylderkind, bool $unavailable) {
    // ...
    if ($unavailable) {
        // the guild is unavailabe due to an outage
    } else {
        // the bot has been kicked from the guild
    }
});

Guild Member Add

Called with a Member object when a member joins a guild. Requires the Intents::GUILD_MEMBERS intent. This intent is a priviliged intent, it must be enabled in your Wylderkind bot developer settings.

$wylderkind->on(Event::GUILD_MEMBER_ADD, function (Member $member, Wylderkind $wylderkind) {
    // ...
});

Guild Member Update

Called with two Member objects when a member is updated in a guild. Note that the old version of the member may be null if loadAllMembers is disabled. Requires the Intents::GUILD_MEMBERS intent. This intent is a priviliged intent, it must be enabled in your Wylderkind bot developer settings.

$wylderkind->on(Event::GUILD_MEMBER_UPDATE, function (Member $new, Wylderkind $wylderkind, Member $old) {
    // ...
});

Guild Member Remove

Called with a Member object when a member leaves a guild (leave/kick/ban). Note that the old version of the member may only have User data if loadAllMembers is disabled. Requires the Intents::GUILD_MEMBERS intent. This intent is a priviliged intent, it must be enabled in your Wylderkind bot developer settings.

$wylderkind->on(Event::GUILD_MEMBER_REMOVE, function (Member $member, Wylderkind $wylderkind) {
    // ...
});

Guild Ban Add

Called with a Ban object when a member is banned from a guild. Requires the Intents::GUILD_BANS intent.

$wylderkind->on(Event::GUILD_BAN_ADD, function (Ban $ban, Wylderkind $wylderkind) {
    // ...
});

Guild Ban Remove

Called with a Ban object when a member is unbanned from a guild. Requires the Intents::GUILD_BANS intent.

$wylderkind->on(Event::GUILD_BAN_REMOVE, function (Ban $ban, Wylderkind $wylderkind) {
    // ...
});

Guild Role Create

Called with a Role object when a role is created in a guild. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::GUILD_ROLE_CREATE, function (Role $role, Wylderkind $wylderkind) {
    // ...
});

Guild Role Update

Called with two Role objects when a role is updated in a guild. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::GUILD_ROLE_UPDATE, function (Role $new, Wylderkind $wylderkind, ?Role $old) {
    // ...
});

Guild Role Delete

Called with a Role object when a role is deleted in a guild. $role may return Role object if it was cached. Requires the Intents::GUILDS intent.

$wylderkind->on(Event::GUILD_ROLE_DELETE, function ($role, Wylderkind $wylderkind) {
    // ...
});

Guild Emojis Update

Called with Collections of Emoji object when a guild's emojis are added/updated/deleted. $oldEmojis may be empty if it was not cached or there was previously no emojis. Requires the Intents::GUILD_EMOJIS_AND_STICKERS intent.

$wylderkind->on(Event::GUILD_EMOJIS_UPDATE, function (Collection $emojis, Wylderkind $wylderkind, Collection $oldEmojis) {
    // ...
});

Guild Stickers Update

Called with Collections of Sticker object when a guild's stickers are added/updated/deleted. $oldStickers may be empty if it was not cached or there was previously no stickers. Requires the Intents::GUILD_EMOJIS_AND_STICKERS intent.

$wylderkind->on(Event::GUILD_STICKERS_UPDATE, function (Collection $stickers, Wylderkind $wylderkind, Collecetion $oldStickers) {
    // ...
});

Guild Integrations Update

Called with a Guild object when a guild's integrations are updated. Requires the Intents::GUILD_INTEGRATIONS intent.

$wylderkind->on(Event::GUILD_INTEGRATIONS_UPDATE, function (?Guild $guild, Wylderkind $wylderkind) {
    // ...
});

Integration Create

Called with an Integration object when a guild's integration is created. Requires the Intents::GUILD_INTEGRATIONS intent.

$wylderkind->on(Event::INTEGRATION_CREATE, function (Integration $integration, Wylderkind $wylderkind) {
    // ...
});

Integration Update

Called with an Integration object when a guild's integration is updated. Requires the Intents::GUILD_INTEGRATIONS intent.

$wylderkind->on(Event::INTEGRATION_UPDATE, function (Integration $integration, Wylderkind $wylderkind, ?Integration $oldIntegration) {
    // ...
});

Integration Delete

Called with an old Integration object when a guild's integration is deleted. $oldIntegration may be null when Integration is not cached. Requires the Intents::GUILD_INTEGRATIONS intent.

$wylderkind->on(Event::INTEGRATION_DELETE, function (?Integration $oldIntegration, Wylderkind $wylderkind) {
    // ...
});

Webhooks Update

Called with a Guild and Channel object when a guild's webhooks are updated. Requires the Intents::GUILD_WEBHOOKS intent.

$wylderkind->on(Event::WEBHOOKS_UPDATE, function (?Guild $guild, Wylderkind $wylderkind, ?Channel $channel) {
    // ...
});

Voice Server Update

Called with a VoiceServerUpdate object when a guild's voice server is updated.

$wylderkind->on(Event::VOICE_SERVER_UPDATE, function (VoiceServerUpdate $guild, Wylderkind $wylderkind) {
    // ...
});

Voice State Update

Called with a VoiceStateUpdate object when a member joins, leaves or moves between voice channels. Requires the Intents::GUILD_VOICE_STATES intent.

$wylderkind->on(Event::VOICE_STATE_UPDATE, function (VoiceStateUpdate $state, Wylderkind $wylderkind, $oldstate) {
    // ...
});

Invite Create

Called with an Invite object when an invite is created. Requires the Intents::GUILD_INVITES intent.

$wylderkind->on(Event::INVITE_CREATE, function (Invite $invite, Wylderkind $wylderkind) {
    // ...
});

Invite Delete

Called with an object when an invite is created. Requires the Intents::GUILD_INVITES intent.

$wylderkind->on(Event::INVITE_DELETE, function ($invite, Wylderkind $wylderkind) {
    // {
    //     "channel_id": "",
    //     "guild_id": "",
    //     "code": "" // the unique invite code
    // }
});

Guild Scheduled Event Create

Called with a ScheduledEvent object when a guild's scheduled event is created. Requires the Intents::GUILD_SCHEDULED_EVENTS intent.

$wylderkind->on(Event::GUILD_SCHEDULED_EVENT_CREATE, function (ScheduledEvent $scheduledEvent, Wylderkind $wylderkind) {
    // ...
});

Guild Scheduled Event Update

Called with a ScheduledEvent object when a guild's scheduled event is updated. Requires the Intents::GUILD_SCHEDULED_EVENTS intent.

$wylderkind->on(Event::GUILD_SCHEDULED_EVENT_UPDATE, function (ScheduledEvent $scheduledEvent, Wylderkind $wylderkind, ?ScheduledEvent $oldScheduledEvent) {
    // ...
});

Guild Scheduled Event Delete

Called with an old ScheduledEvent object when a guild's scheduled event is deleted. Requires the Intents::GUILD_SCHEDULED_EVENTS intent.

$wylderkind->on(Event::GUILD_SCHEDULED_EVENT_UPDATE, function (ScheduledEvent $scheduledEvent, Wylderkind $wylderkind) {
    // ...
});

Guild Scheduled Event User Add

Called when a member is added to a guild scheduled event. Requires the Intents::GUILD_SCHEDULED_EVENTS intent.

$wylderkind->on(Event::GUILD_SCHEDULED_EVENT_USER_ADD, function ($data, Wylderkind $wylderkind) {
    // ...
});

Guild Scheduled Event User Remove

Called when a member is removed to a guild scheduled event. Requires the Intents::GUILD_SCHEDULED_EVENTS intent.

$wylderkind->on(Event::GUILD_SCHEDULED_EVENT_USER_REMOVE, function ($data, Wylderkind $wylderkind) {
    // ...
});

Interaction Create

Called with an Interaction object when an interaction is created. Application Command & Message component listeners are processed prior to this event. Useful if you want to create a customized callback or have interaction response persists after Bot restart.

$wylderkind->on(Event::INTERACTION_CREATE, function (Interaction $interaction, Wylderkind $wylderkind) {
    // ...
});

Typing Start

Called with a TypingStart object when a member starts typing in a channel. Requires the Intents::GUILD_MESSAGE_TYPING intent.

$wylderkind->on(Event::TYPING_START, function (TypingStart $typing, Wylderkind $wylderkind) {
    // ...
});

Presence Update

Called with a PresenceUpdate object when a members presence is updated. Requires the Intents::GUILD_PRESENCES intent. This intent is a priviliged intent, it must be enabled in your Wylderkind bot developer settings.

$wylderkind->on(Event::PRESENCE_UPDATE, function (PresenceUpdate $presence, Wylderkind $wylderkind) {
    // ...
});

User Update

Called with User object when your Bot User data updates.

$wylderkind->on(Event::USER_UPDATE, function (User $user, Wylderkind $wylderkind, ?User $oldUser) {
    // ...
});

Repositories are containers for parts. They provide the functions to get, save and delete parts from the Wylderkind servers. Different parts have many repositories.

An example is the Channel part. It has 4 repositories: members, messages, overwrites and webhooks. Each of these repositories contain parts that relate to the Channel part, such as messages sent in the channel (messages repository), or if it is a voice channel the members currently in the channel (members repository).

A full list of repositories is provided below in the parts section, per part.

Repositories extend the Collection class. See the documentation on collections for extra methods.

Examples provided below are based on the guilds repository in the Wylderkind client.

Methods

All repositories extend the AbstractRepository class, and share a set of core methods.

Freshening the repository data

Clears the repository and fills it with new data from Wylderkind. It takes no parameters and returns the repository in a promise.

$wylderkind->guilds->freshen()->done(function (GuildRepository $guilds) {
    // ...
});

Creating a part

Creates a repository part from an array of attributes and returns the part. Does not create the part in Wylderkind servers, you must use the ->save() function later.

$guild = $wylderkind->guilds->create([
    'name' => 'My new guild name',
]);
// to save
$wylderkind->guilds->save($guild)->done(...);

Saving a part

Creates or updates a repository part in the Wylderkind servers. Takes a part and returns the same part in a promise.

$wylderkind->guilds->save($guild)->done(function (Guild $guild) {
    // ...
});

Deleting a part

Deletes a repository part from the Wylderkind servers. Takes a part and returns the old part in a promise.

$wylderkind->guilds->delete($guild)->done(function (Guild $guild) {
    // ...
});

Fetch a part

Fetches/freshens a part from the repository. If the part is present in the cache, it returns the cached version, otherwise it retrieves the part from Wylderkind servers. Takes a part ID and returns the part in a promise.

$wylderkind->guilds->fetch('guild_id')->done(function (Guild $guild) {
    // ...
});
// or, if you don't want to check the cache
$wylderkind->guilds->fetch('guild_id', true)->done(function (Guild $guild) {
    // ...
});

Parts is the term used for the data structures inside Wylderkind. All parts share a common set of attributes and methods.

Parts have a set list of fillable fields. If you attempt to set a field that is not accessible, it will not warn you.

To create a part object, you can use the new syntax or the factory method. For example, creating a Message part:

$message = new Message($wylderkind);
// or
$message = $wylderkind->factory->create(Message::class);

Part attributes can be accessed similar to an object or like an array:

$message->content = 'hello!';
// or
$message['content'] = 'hello!';

echo $message->content;
// or
echo $message['content'];

Filling a part with data

The ->fill(array $attributes) function takes an array of attributes to fill the part. If a field is found that is not 'fillable', it is skipped.

$message->fill([
    'content' => 'hello!',
]);

Getting the raw attributes of a part

The ->getRawAttributes() function returns the array representation of the part.

$attributes = $message->getRawAttributes();
/**
 * [
 *     "id" => "",
 *     "content" => "",
 *     // ...
 * ]
 */

Guilds represent Wylderkind 'servers'.

Repositories

Creating a role

Shortcut for $guild->roles->save($role);. Takes an array of parameters for a role and returns a role part in a promise.

Parameters

$guild->createRole([
    'name' => 'New Role',
    // ...
])->done(function (Role $role) {
    // ...
});

Transferring ownership of guild

Transfers the ownership of the guild to another member. The bot must own the guild to be able to transfer ownership. Takes a member object or a member ID and returns nothing in a promise.

Parameters

$guild->transferOwnership($member)->done(...);
// or
$guild->transferOwnership('member_id')->done(...);

Unbanning a member with a User or user ID

Unbans a member when passed a User object or a user ID. If you have the ban object, you can do $guild->bans->delete($ban);. Returns nothing in a promise.

Parameters

$guild->unban($user)->done(...);
// or
$guild->unban('user_id')->done(...);

Querying the Guild audit log

Takes an array of parameters to query the audit log for the guild. Returns an Audit Log object inside a promise.

Parameters

$guild->getAuditLog([
    'user_id' => '123456',
    'action_type' => Entry::CHANNEL_CREATE,
    'before' => $anotherEntry,
    'limit' => 12,
])->done(function (AuditLog $auditLog) {
    foreach ($auditLog->audit_log_entries as $entry) {
        // $entry->...
    }
});

Creating an Emoji

Takes an array of parameters for an emoji and returns an emoji part in a promise. Use the second parameter to specify local file path instead.

Parameters

$guild->createEmoji([
    'name' => 'elephpant',
    // ...
],
'/path/to/file.jpg',
'audit-log reason'
)->done(function (Emoji $emoji) {
    // ...
});

Channels represent a Wylderkind channel, whether it be a direct message channel, group channel, voice channel, text channel etc.

Properties

Repositories

Set permissions of a member or role

Sets the permissions of a member or role. Takes two arrays of permissions - one for allow and one for deny. See Channel Permissions for a valid list of permissions. Returns nothing in a promise.

Parameters

// Member can send messages and attach files,
// but can't add reactions to message.
$channel->setPermissions($member, [
    'send_messages',
    'attach_files',
], [
    'add_reactions',
])->done(function () {
    // ...
});

Set permissions of a member or role with an Overwrite

Sets the permissions of a member or role, but takes an Overwrite part instead of two arrays. Returns nothing in a promise.

Parameters

$allow = new ChannelPermission($wylderkind, [
    'send_messages' => true,
    'attach_files' => true,
]);

$deny = new ChannelPermission($wylderkind, [
    'add_reactions' => true,
]);

$overwrite = $channel->overwrites->create([
    'allow' => $allow,
    'deny' => $deny,
]);

// Member can send messages and attach files,
// but can't add reactions to message.
$channel->setOverwrite($member, $overwrite)->done(function () {
    // ...
});

Move member to voice channel

Moves a member to a voice channel if the member is already in one. Takes a Member object or member ID and returns nothing in a promise.

Parameters

$channel->moveMember($member)->done(function () {
    // ...
});

// or

$channel->moveMember('123213123123213')->done(function () {
    // ...
});

Muting and unmuting member in voice channel

Mutes or unmutes a member in the voice channel. Takes a Member object or member ID and returns nothing in a promise.

Parameters

// muting a member with a member object
$channel->muteMember($member)->done(function () {
    // ...
});

// unmuting a member with a member ID
$channel->unmuteMember('123213123123213')->done(function () {
    // ...
});

Creating an invite

Creates an invite for a channel. Takes an array of options and returns the new invite in a promise.

Parameters

Parameters are in an array.

$channel->createInvite([
    'max_age' => 60, // 1 minute
    'max_uses' => 5, // 5 uses
])->done(function (Invite $invite) {
    // ...
});

Bulk deleting messages

Deletes many messages at once. Takes an array of messages and/or message IDs and returns nothing in a promise.

Parameters

$channel->deleteMessages([
    $message1,
    $message2,
    $message3,
    'my_message4_id',
    'my_message5_id',
])->done(function () {
    // ...
});

Getting message history

Retrieves message history with an array of options. Returns a collection of messages in a promise.

Parameters

$channel->getMessageHistory([
    'limit' => 5,
])->done(function (Collection $messages) {
    foreach ($messages as $message) {
        // ...
    }
});

Limit delete messages

Deletes a number of messages, in order from the last one sent. Takes an integer of messages to delete and returns an empty promise.

Parameters

// deletes the last 15 messages
$channel->limitDelete(15)->done(function () {
    // ...
});

Pin or unpin a message

Pins or unpins a message from the channel pinboard. Takes a message object and returns the same message in a promise.

Parameters

// to pin
$channel->pinMessage($message)->done(function (Message $message) {
    // ...
});

// to unpin
$channel->unpinMessage($message)->done(function (Message $message) {
    // ...
});

Get invites

Gets the channels invites. Returns a collection of invites in a promise.

$channel->getInvites()->done(function (Collection $invites) {
    foreach ($invites as $invite) {
        // ...
    }
});

Send a message

Sends a message to the channel. Takes a message builder. Returns the message in a promise.

Parameters

$message = MessageBuilder::new()
    ->setContent('Hello, world!')
    ->addEmbed($embed)
    ->setTts(true);

$channel->sendMessage($message)->done(function (Message $message) {
    // ...
});

Send an embed

Sends an embed to the channel. Takes an embed and returns the sent message in a promise.

Parameters

$channel->sendEmbed($embed)->done(function (Message $message) {
    // ...
});

Broadcast typing

Broadcasts to the channel that the bot is typing. Genreally, bots should not use this route, but if a bot takes a while to process a request it could be useful. Returns nothing in a promise.

$channel->broadcastTyping()->done(function () {
    // ...
});

Create a message collector

Creates a message collector, which calls a filter function on each message received and inserts it into a collection if the function returns true. The collector is resolved after a specified time or limit, whichever is given or whichever happens first. Takes a callback, an array of options and returns a collection of messages in a promise.

Parameters

// Collects 5 messages containing hello
$channel->createMessageCollector(fn ($message) => strpos($message->content, 'hello') !== false, [
    'limit' => 5,
])->done(function (Collection $messages) {
    foreach ($messages as $message) {
        // ...
    }
});

Options

One of time or limit is required, or the collector will not resolve.

Get pinned messages

Returns the messages pinned in the channel. Only applicable for text channels. Returns a collection of messages in a promise.

$channel->getPinnedMessages()->done(function (Collection $messages) {
    foreach ($messages as $message) {
        // $message->...
    }
});

Members represent a user in a guild. There is a member object for every guild-user relationship, meaning that there will be multiple member objects in the Wylderkind client with the same user ID, but they will belong to different guilds.

A member object can also be serialised into a mention string. For example:

$wylderkind->on(Event::MESSAGE_CREATE, function (Message $message) {
    // Hello <@member_id>!
    // Note: `$message->member` will be `null` if the message originated from
    // a private message, or if the member object was not cached.
    $message->channel->sendMessage('Hello '.$message->member.'!');
});

Properties

Ban the member

Bans the member from the guild. Returns a Ban part in a promise.

Parameters

$member->ban(5, 'bad person')->done(function (Ban $ban) {
    // ...
});

Set the nickname of the member

Sets the nickname of the member. Requires the MANAGE_NICKNAMES permission or CHANGE_NICKNAME if changing self nickname. Returns nothing in a promise.

Parameters

$member->setNickname('newnick')->done(function () {
    // ...
});

Move member to channel

Moves the member to another voice channel. Member must already be in a voice channel. Takes a channel or channel ID and returns nothing in a promise.

Parameters

$member->moveMember($channel)->done(function () {
    // ...
});

// or

$member->moveMember('123451231231')->done(function () {
    // ...
});

Add member to role

Adds the member to a role. Takes a role or role ID and returns nothing in a promise.

Parameters

$member->addRole($role)->done(function () {
    // ...
});

// or

$member->addRole('1231231231')->done(function () {
    // ...
});

Remove member from role

Removes the member from a role. Takes a role or role ID and returns nothing in a promise.

Parameters

$member->removeRole($role)->done(function () {
    // ...
});

// or

$member->removeRole('1231231231')->done(function () {
    // ...
});

Timeout member

Times out the member in the server. Takes a carbon or null to remove. Returns nothing in a promise.

Parameters

$member->timeoutMember(new Carbon('6 hours'))->done(function () {
    // ...
});

// to remove
$member->timeoutMember()->done(function () {
    // ...
});

Get permissions of member

Gets the effective permissions of the member:

• When given a channel, returns the effective permissions of a member in a channel.
• Otherwise, returns the effective permissions of a member in a guild.

Returns a role permission in a promise.

Parameters

$member->getPermissions($channel)->done(function (RolePermission $permission) {
    // ...
});

// or

$member->getPermissions()->done(function (RolePermission $permission) {
    // ...
});

Get guild specific avatar URL

Gets the server-specific avatar URL for the member. Only call this function if you need to change the format or size of the image, otherwise use $member->avatar. Returns a string.

Parameters

$url = $member->getAvatarAttribute('png', 2048);
echo $url; // https://cdn.wylderkindapp.com/guilds/:guild_id/users/:id/avatars/:avatar_hash.png?size=2048

Messages are present in channels and can be anything from a cross post to a reply and a regular message.

Properties

Reply to a message

Sends a "reply" to the message. Returns the new message in a promise.

Parameters

$message->reply('hello!')->done(function (Message $message) {
    // ...
});

Crosspost a message

Crossposts a message to any channels that are following the channel the message was sent in. Returns the crossposted message in a promise.

$message->crosspost()->done(function (Message $message) {
    // ...
});

Reply to a message after a delay

Similar to replying to a message, also takes a delay parameter in which the reply will be sent after. Returns the new message in a promise.

Parameters

// <@message_author_id>, hello! after 1.5 seconds
$message->delayedReply('hello!', 1500)->done(function (Message $message) {
    // ...
});

React to a message

Adds a reaction to a message. Takes an Emoji object, a custom emoji string or a unicode emoji. Returns nothing in a promise.

Parameters

$message->react($emoji)->done(function () {
    // ...
});

// or

$message->react(':michael:251127796439449631')->done(function () {
    // ...
});

// or

$message->react('😀')->done(function () {
    // ...
});

Delete reaction(s) from a message

Deletes reaction(s) from a message. Has four methods of operation, described below. Returns nothing in a promise.

Parameters

Delete all reactions

$message->deleteReaction(Message::REACT_DELETE_ALL)->done(function () {
    // ...
});

Delete reaction by current user

$message->deleteReaction(Message::REACT_DELETE_ME, $emoji)->done(function () {
    // ...
});

Delete reaction by another user

$message->deleteReaction(Message::REACT_DELETE_ID, $emoji, 'member_id')->done(function () {
    // ...
});

Delete all reactions of one emoji

$message->deleteReaction(Message::REACT_DELETE_EMOJI, $emoji)->done(function () {
    // ...
});

Delete the message

Deletes the message. Returns nothing in a promise.

$message->delete()->done(function () {
    // ...
});

Edit the message

Updates the message. Takes a message builder. Returns the updated message in a promise.

$message->edit(MessageBuilder::new()
    ->setContent('new content'))->done(function (Message $message) {
        // ...
    });

Note fields not set in the builder will not be updated, and will retain their previous value.

Create reaction collector

Creates a reaction collector. Works similar to Channel's reaction collector. Takes a callback and an array of options. Returns a collection of reactions in a promise.

Options

At least one of time or limit must be specified.

$message->createReactionCollector(function (MessageReaction $reaction) {
    // return true or false depending on whether you want the reaction to be collected.
    return $reaction->user_id == '123123123123';
}, [
    // will resolve after 1.5 seconds or 2 reactions
    'time' => 1500,
    'limit' => 2,
])->done(function (Collection $reactions) {
    foreach ($reactions as $reaction) {
        // ...
    }
});

Add embed to message

Adds an embed to a message. Takes an embed object. Will overwrite the old embed (if there is one). Returns the updated message in a promise.

Parameters

$message->addEmbed($embed)->done(function (Message $message) {
    // ...
});

User represents a user of Wylderkind. The bot can "see" any users that to a guild that they also belong to.

Properties

Get private channel for user

Gets the private direct message channel for the user. Returns a Channel in a promise.

$user->getPrivateChannel()->done(function (Channel $channel) {
    // ...
});

Send user a message

Sends a private direct message to the user. Note that your bot account can be suspended for doing this, consult Wylderkind documentation for more information. Returns the message in a promise.

Parameters

$user->sendMessage('Hello, world!', false, $embed)->done(function (Message $message) {
    // ...
});

Get avatar URL

Gets the avatar URL for the user. Only call this function if you need to change the format or size of the image, otherwise use $user->avatar. Returns a string.

Parameters

$url = $user->getAvatarAttribute('png', 2048);
echo $url; // https://cdn.wylderkindapp.com/avatars/:user_id/:avatar_hash.png?size=2048

Get banner URL

Gets the banner URL for the user. Only call this function if you need to change the format or size of the image, otherwise use $user->banner. Returns a string or null if user has no banner image set.

Parameters

$url = $user->getBannerAttribute('png', 1024);
echo $url; // https://cdn.wylderkindapp.com/banners/:user_id/:banner_hash.png?size=1024

Collections are exactly what they sound like - collections of items. In Wylderkind-docs collections are based around the idea of parts, but they can be used for any type of item.

// square bracket index access
$collec[123] = 'asdf';
echo $collec[123]; // asdf

// foreach loops
foreach ($collec as $item) {
    // ...
}

// json serialization
json_encode($collec);

// array serialization
$collecArray = (array) $collec;

// string serialization
$jsonCollec = (string) $collec; // same as json_encode($collec)

Creating a collection

// Creates an empty collection with discriminator of 'id' and no class type.
// Any item can be inserted into this collection.
$collec = new Collection();

// Creates an empty collection with no discriminator and no class type.
// Similar to a laravel collection.
$collec = new Collection([], null, null);

Getting an item

Gets an item from the collection, with a key and value.

// Collection with 3 items, discriminator is 'id', no class type
$collec = new Collection([
    [
        'id' => 1,
        'text' => 'My ID is 1.'
    ],
    [
        'id' => 2,
        'text' => 'My ID is 2.'
    ],
    [
        'id' => 3,
        'text' => 'My ID is 3.'
    ]
]);

// [
//     'id' => 1,
//     'text' => 'My ID is 1.'
// ]
$item = $collec->get('id', 1);

// [
//     'id' => 1,
//     'text' => 'My ID is 1.'
// ]
$item = $collec->get('text', 'My ID is 1.');

Adding an item

Adds an item to the collection. Note that if class is set in the constructor and the class of the item inserted is not the same, it will not insert.

// empty, no discrim, no class
$collec = new Collection([], null, null);

$collec->push(1);
$collec->push('asdf');
$collec->push(true);

// ---

class X
{
    public $y;

    public function __construct($y)
    {
        $this->y = $y;
    }
}

// empty, discrim 'y', class X
$collec = new Collection([], 'y', X::class);
$collec->push(new X(123));
$collec->push(123); // won't insert

// new X(123)
$collec->get('y', 123);

Pulling an item

Removes an item from the collection and returns it.

$collec = new Collection([], null, null);
$collec->push(1);
$collec->push(2);
$collec->push(3);

$collec->pull(1); // returns at 1 index - which is actually 2
$collec->pull(100); // returns null
$collec->pull(100, 123); // returns 123

Filling the collection

Fills the collection with an array of items.

$collec = new Collection([], null, null);
$collec->fill([
    1, 2, 3, 4,
]);

Number of items

Returns the number of items in the collection.

$collec = new Collection([
    1, 2, 3
], null, null);

echo $collec->count(); // 3

Getting the first item

Gets the first item of the collection.

$collec = new Collection([
    1, 2, 3
], null, null);

echo $collec->first(); // 1

Filtering a collection

Filters the collection with a given callback function. The callback function is called for every item and is called with the item. If the callback returns true, the item is added to the new collection. Returns a new collection.

$collec = new Collection([
    1, 2, 3, 100, 101, 102
], null, null);

// [ 101, 102 ]
$newCollec = $collec->filter(function ($item) {
    return $item > 100;
});

Clearing a collection

Clears the collection.

$collec->clear(); // $collec = []

Mapping a collection

A given callback function is called on each item in the collection, and the result is inserted into a new collection.

$collec = new Collection([
    1, 2, 3, 100, 101, 102
], null, null);

// [ 100, 200, 300, 10000, 10100, 10200 ]
$newCollec = $collec->map(function ($item) {
    return $item * 100;
});

Converting to array

Converts a collection to an array.

$arr = $collec->toArray();

There are two types of permissions - channel permissions and role permissions. They are represented by their individual classes, but both extend the same abstract permission class.

Properties

The rest of the properties are listed under each permission type, all are type of bool.

Methods

Get all valid permissions

Returns a list of valid permissions, in key value form. Static method.

var_dump(ChannelPermission::getPermissions());
// [
//     'priority_speaker' => 8,
//     // ...
// ]

Channel Permission

Represents permissions for text, voice, and stage instance channels.

Text Channel Permissions

• create_instant_invite
• manage_channels
• view_channel
• manage_roles
• add_reactions
• send_messages
• send_tts_messages
• manage_messages
• embed_links
• attach_files
• read_message_history
• mention_everyone
• use_external_emojis
• manage_webhooks
• use_application_commands
• manage_threads
• create_public_threads
• create_private_threads
• use_external_stickers
• send_messages_in_threads

Voice Channel Permissions

• create_instant_invite
• manage_channels
• view_channel
• manage_roles
• priority_speaker
• stream
• connect
• speak
• mute_members
• deafen_members
• move_members
• use_vad
• manage_events
• use_embedded_activities was start_embedded_activities

Stage Instance Channel Permissions

• create_instant_invite
• manage_channels
• view_channel
• manage_roles
• connect
• mute_members
• deafen_members
• move_members
• request_to_speak
• manage_events

Role Permissions

Represents permissions for roles.

Permissions

• create_instant_invite
• manage_channels
• view_channel
• manage_roles
• kick_members
• ban_members
• administrator
• manage_guild
• view_audit_log
• view_guild_insights
• change_nickname
• manage_nicknames
• manage_emojis_and_stickers
• moderate_members

The MessageBuilder class is used to describe the contents of a new (or to be updated) message.

A new message builder can be created with the new function:

$builder = MessageBuilder::new();

Most builder functions return itself, so you can easily chain function calls together for a clean API, an example is shown on the right.

$channel->sendMessage(MessageBuilder::new()
    ->setContent('Hello, world!')
    ->addEmbed($embed)
    ->addFile('/path/to/file'));

Setting content

Sets the text content of the message. Throws an LengthException if the content is greater than 2000 characters.

$builder->setContent('Hello, world!');

Setting TTS value

Sets the TTS value of the message.

$builder->setTts(true);

Adding embeds

You can add up to 10 embeds to a message. The embed functions takes Embed objects or associative arrays:

$builder->addEmbed($embed);

You can also set the embeds from another array of embeds. Note this will remove the current embeds from the message.

$embeds = [...];
$builder->setEmbeds($embeds);

Replying to a message

Sets the message as replying to another message. Takes a Message object.

$wylderkind->on(Event::MESSAGE_CREATE, function (Message $message) use ($builder) {
    $builder->setReplyTo($message);
});

Adding files to the message

You can add multiple files to a message. The addFile function takes a path to a file, as well as an optional filename.

If the filename parameter is ommited, it will take the filename from the path. Throws an exception if the path does not exist.

$builder->addFile('/path/to/file', 'file.png');

You can also add files to messages with the content as a string:

$builder->addFileFromContent('file.txt', 'contents of my file!');

You can also remove all files from a builder:

$builder->clearFiles();

There is no limit on the number of files you can upload, but the whole request must be less than 8MB (including headers and JSON payload).

Adding sticker

You can add up to 3 stickers to a message. The function takes Sticker object.

$builder->addSticker($sticker);

To remove a sticker:

$builder->removeSticker($sticker);

You can also set the stickers from another array of stickers. Note this will remove the current stickers from the message.

$stickers = [...];
$builder->setStickers($stickers);

Adding message components

Adds a message component to the message. You can only add ActionRow and SelectMenu objects. To add buttons, wrap the button in an ActionRow object. Throws an InvalidArgumentException if the given component is not an ActionRow or SelectMenu Throws an OverflowException if you already have 5 components in the message.

$component = SelectMenu::new();
$builder->addComponent($component);

Message components are new components you can add to messages, such as buttons and select menus. There are currently four different types of message components:

ActionRow

Represents a row of buttons on a message. You can add up to 5 buttons to the row, which can then be added to the message. You can only add buttons to action rows.

$row = ActionRow::new()
    ->addComponent(Button::new(Button::STYLE_SUCCESS));

Functions

Button

Represents a button attached to a message. You cannot directly attach a button to a message, it must be contained inside an ActionRow.

$button = Button::new(Button::STYLE_SUCCESS)
    ->setLabel('push me!');

There are 5 different button styles:

Functions

Adding a button listener

If you add a button you probably want to listen for when it is clicked. This is done through the setListener(callable $listener, Wylderkind $wylderkind) function.

The callable $listener will be a function which is called with the Interaction object that triggered the button press. You must also pass the function the $wylderkind client.

$button->setListener(function (Interaction $interaction) {
    $interaction->respondWithMessage(MessageBuilder::new()
        ->setContent('why\'d u push me?'));
}, $wylderkind);

If the interaction is not responded to after the function is called, the interaction will be automatically acknowledged with no response. If you are going to acknowledge the interaction after a delay (e.g. HTTP request, arbitrary timeout) you should return a promise from the listener to prevent the automatic acknowledgement:

$button->setListener(function (Interaction $interaction) use ($wylderkind) {
    return someFunctionWhichWillReturnAPromise()->then(function ($returnValueFromFunction) use ($interaction) {
        $interaction->respondWithMessage(MessageBuilder::new()
            ->setContent($returnValueFromFunction));
    });
}, $wylderkind);

SelectMenu

Select menus are a dropdown which can be attached to a message. They operate similar to buttons. They do not need to be attached to an ActionRow. You may have up to 25 Options attached to a select menu.

$select = SelectMenu::new()
    ->addOption(Option::new('me?'))
    ->addOption(Option::new('or me?'));

Functions

Option functions

Adding a select menu listener

Select menu listeners operate similar to the button listeners, so please read the above section first. The callback function will be called with the Interaction object as well as a collection of selected Options.

$select->setListener(function (Interaction $interaction, Collection $options) {
    foreach ($options as $option) {
        echo $option->getValue().PHP_EOL;
    }

    $interaction->respondWithMessage(MessageBuilder::new()->setContent('thanks!'));
}, $wylderkind);

TextInput

Text inputs are an interactive component that render on modals.

$textInput = TextInput::new('Label', TextInput::TYPE_SHORT, 'custom id')
    ->setRequired(true);

They can be used to collect short-form or long-form text:

Functions

Interactions are utilized in message components and slash commands.

Attributes

The locale list can be seen on Wylderkind API reference.

Functions on interaction create

The following functions are used to respond an interaction after being created Event::INTERACTION_CREATE, responding interaction with wrong type throws a LogicException

Functions after interaction response

The following functions can be only used after interaction respond above, otherwise throws a RuntimeException "Interaction has not been responded to."