disgord

package module
Version: v0.16.13 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 2, 2020 License: BSD-3-Clause Imports: 34 Imported by: 2

README

About

Go module with context support that handles some of the difficulties from interacting with Discord's bot interface for you; websocket sharding, auto-scaling of websocket connections, advanced caching, helper functions, middlewares and lifetime controllers for event handlers, etc.

Warning

The develop branch is under continuous breaking changes, as the interface and exported funcs/consts are still undergoing planning. Because Disgord is under development and pushing for a satisfying interface, the SemVer logic is not according to spec. Until v1.0.0, every minor release is considered possibly breaking and patch releases might contain additional features. Please see the issue and current PR's to get an idea about coming changes before v1.

There might be bugs in the cache, or the cache processing might not exist yet for some REST methods. Bypass the cache for REST methods by supplying the flag argument disgord.IgnoreCache. eg. client.GetCurrentUser(disgord.IgnoreCache).

Remember to read the docs/code for whatever version of disgord you are using. This README file reflects the latest state in the develop branch, or at least, I try to reflect the latest state.

Data types & tips

  • Use disgord.Snowflake, not snowflake.Snowflake.
  • Use disgord.Time, not time.Time when dealing with Discord timestamps. This is because Discord returns a weird time format.

Starter guide

This project uses Go Modules for dealing with dependencies, remember to activate module support in your IDE

Examples can be found in docs/examples and some open source projects Disgord projects in the wiki

I highly suggest reading the Discord API documentation and the Disgord go doc.

Here is a basic bot program that prints out every message. Save it as main.go, run go mod init bot and go mod download. You can then start the bot by writing go run .

package main

import (
    "context"
    "fmt"
    "github.com/Noctember/disgord"
    "os"
)

func printMessage(session disgord.Session, evt *disgord.MessageCreate) {
    msg := evt.Message
    fmt.Println(msg.Author.String() + ": "+ msg.Content) // Anders#7248{435358734985}: Hello there
}

func main() {
    client := disgord.New(disgord.Config{
        BotToken: os.Getenv("DISGORD_TOKEN"),
        // You can inject any logger that implements disgord.Logger interface (eg. logrus)
        // Disgord provides a simple logger to get you started. Nothing is logged if nil.
        Logger: disgord.DefaultLogger(false), // debug=false
    })
    // connect, and stay connected until a system interrupt takes place
    defer client.StayConnectedUntilInterrupted(context.Background())
    
    // create a handler and bind it to new message events
    // handlers/listener are run in sequence if you register more than one
    // so you should not need to worry about locking your objects unless you do any
    // parallel computing with said objects
    client.On(disgord.EvtMessageCreate, printMessage)
}
Linux script

To create a new bot you can use the disgord.sh script to get a bot with some event middlewares and Dockerfile. Paste the following into your terminal:

bash <(curl -s -L https://git.io/disgord-script)

Starter guide as a gif: https://terminalizer.com/view/469961d0695

Architecture & Behavior

Discord provide communication in different forms. Disgord tackles the main ones, events (ws), voice (udp + ws), and REST calls.

You can think of Disgord as layered, in which case it will look something like: Simple way to think about Disgord architecture from a layered perspective

Events

For Events, Disgord uses the reactor pattern. Every incoming event from Discord is processed and checked if any handler is registered for it, otherwise it's discarded to save time and resource use. Once a desired event is received, Disgord starts up a Go routine and runs all the related handlers in sequence; avoiding locking the need to use mutexes the handlers.

In addition to traditional handlers, Disgord allows you to use Go channels. Note that if you use more than one channel per event, one of the channels will randomly receive the event data; this is how go channels work. It will act as a randomized load balancer.

But before either channels or handlers are triggered, the cache is updated.

REST

The "REST manager", or the httd.Client, handles rate limiting for outgoing requests, and updated the internal logic on responses. All the REST methods are defined on the disgord.Client and checks for issues before the request is sent out.

If the request is a standard GET request, the cache is always checked first to reduce delay, network traffic and load on the Discord servers. And on responses, regardless of the http method, the data is copied into the cache.

Some of the REST methods (updating existing data structures) will use the builder+command pattern. While the remaining will take a simple config struct.

Note: Methods that update a single field, like SetCurrentUserNick, does not use the builder pattern.

// bypasses local cache
client.GetCurrentUser(context.Background(), disgord.IgnoreCache)
client.GetGuildMembers(context.Background(), guildID, disgord.IgnoreCache)

// always checks the local cache first
client.GetCurrentUser(context.Background())
client.GetGuildMembers(context.Background(), guildID)
Voice

Whenever you want the bot to join a voice channel, a websocket and UDP connection is established. So if your bot is currently in 5 voice channels, then you have 5 websocket connections and 5 udp connections open to handle the voice traffic.

Cache

The cache tries to represent the Discord state as accurate as it can. Because of this, the cache is immutable by default. Meaning the does not allow you to reference any cached objects directly, and every incoming and outgoing data of the cache is deep copied.

Contributing

Please see the CONTRIBUTING.md file (Note that it can be useful to read this regardless if you have the time)

You can contribute with pull requests, issues, wiki updates and helping out in the discord servers mentioned above.

To notify about bugs or suggesting enhancements, simply create a issue. The more the better. But be detailed enough that it can be reproduced and please provide logs.

To contribute with code, always create an issue before you open a pull request. This allows automating change logs and releases.

Q&A

NOTE: To see more examples go to the docs/examples folder. See the GoDoc for a in-depth introduction on the various topics.

1. How do I find my bot token and/or add my bot to a server?

Tutorial here: https://github.com/andersfylling/disgord/wiki/Get-bot-token-and-add-it-to-a-server
2. Is there an alternative Go package?

Yes, it's called DiscordGo (https://github.com/bwmarrin/discordgo). Its purpose is to provide a 
minimalistic API wrapper for Discord, it does not handle multiple websocket sharding, scaling, etc. 
behind the scenes such as Disgord does. Currently I do not have a comparison chart of Disgord and 
DiscordGo. But I do want to create one in the future, for now the biggest difference is that 
Disgord does not support self bots.
3. Why make another Discord lib in Go?

I'm trying to take over the world and then become a intergalactic war lord. Have to start somewhere.
4. Does this project re-use any code from DiscordGo?

Yes. See guild.go. The permission consts are pretty much a copy from DiscordGo.
5. Will Disgord support self bots?

No. Self bots are againts ToS and could result in account termination (see
https://support.discordapp.com/hc/en-us/articles/115002192352-Automated-user-accounts-self-bots-). 
In addition, self bots aren't a part of the official Discord API, meaning support could change at any 
time and Disgord could break unexpectedly if this feature were to be added.

Documentation

Overview

Package disgord provides Go bindings for the documented Discord API, and allows for a stateful Client using the Session interface, with the option of a configurable caching system or bypass the built-in caching logic all together.

Getting started

Create a Disgord session to get access to the REST API and socket functionality. In the following example, we listen for new messages and write a "hello" message when our handler function gets fired.

Session interface: https://godoc.org/github.com/andersfylling/disgord/#Session

discord := disgord.New(&disgord.Config{
  BotToken: "my-secret-bot-token",
})
defer discord.StayConnectedUntilInterrupted()

// listen for incoming messages and reply with a "hello"
discord.On(event.MessageCreate, func(s disgord.Session, evt *disgord.MessageCreate) {
    msg := evt.Message
    msg.Reply(s, "hello")
})

// If you want some logic to fire when the bot is ready
// (all shards has received their ready event), please use the Ready method.
discord.Ready(func() {
	fmt.Println("READY NOW!")
})

Listen for events using Channels

Disgord also provides the option to listen for events using a channel. The setup is exactly the same as registering a function. Simply define your channel, add buffering if you need it, and register it as a handler in the `.On` method.

msgCreateChan := make(chan *disgord.MessageCreate, 10)
session.On(disgord.EvtMessageCreate, msgCreateChan)

Never close a channel without removing the handler from Disgord. You can't directly call Remove, instead you inject a controller to dictate the handler's lifetime. Since you are the owner of the channel, disgord will never close it for you.

ctrl := &disgord.Ctrl{Channel: msgCreateChan}
session.On(disgord.EvtMessageCreate, msgCreateChan, ctrl)
go func() {
  // close the channel after 20 seconds and safely remove it from Disgord
  // without Disgord trying to send data through it after it has closed
  <- time.After(20 * time.Second)
  ctrl.CloseChannel()
}

Here is what it would look like to use the channel for handling events. Please run this in a go routine unless you know what you are doing.

for {
    var message *disgord.Message
    var status string
    select {
    case evt, alive := <- msgCreateChan
        if !alive {
            return
        }
        msg = evt.Message
        status = "created"
    }

    fmt.Printf("A message from %s was %s\n", msg.Author.Mention(), status)
    // output: "A message from @Anders was created"
}

WebSockets and Sharding

Disgord handles sharding for you automatically; when starting the bot, when discord demands you to scale up your shards (during runtime), etc. It also gives you control over the shard setup in case you want to run multiple instances of Disgord (in these cases you must handle scaling yourself as Disgord can not).

Sharding is done behind the scenes, so you do not need to worry about any settings. Disgord will simply ask Discord for the recommended amount of shards for your bot on startup. However, to set specific amount of shards you can use the `disgord.ShardConfig` to specify a range of valid shard IDs (starts from 0).

starting a bot with exactly 5 shards

client := disgord.New(&disgord.Config{
  ShardConfig: disgord.ShardConfig{
    // this is a copy so u can't manipulate the config later on
    ShardIDs: []uint{0,1,2,3,4},
  },
})

Running multiple instances each with 1 shard (note each instance must use unique shard ids)

client := disgord.New(&disgord.Config{
  ShardConfig: disgord.ShardConfig{
    // this is a copy so u can't manipulate the config later on
    ShardIDs: []uint{0}, // this number must change for each instance. Try to automate this.
    ShardCount: 5, // total of 5 shards, but this disgord instance only has one. AutoScaling is disabled - use OnScalingRequired.
  },
})

Handle scaling options yourself

client := disgord.New(&disgord.Config{
  ShardConfig: disgord.ShardConfig{
    // this is a copy so u can't manipulate it later on
    DisableAutoScaling: true,
    OnScalingRequired: func(shardIDs []uint) (TotalNrOfShards uint, AdditionalShardIDs []uint) {
      // instead of asking discord for exact number of shards recommended
      // this is increased by 50% every time discord complains you don't have enough shards
      // to reduce the number of times you have to scale
      TotalNrOfShards := uint(len(shardIDs) * 1.5)
      for i := len(shardIDs) - 1; i < TotalNrOfShards; i++ {
        AdditionalShardIDs = append(AdditionalShardIDs, i)
      }
      return
    }, // end OnScalingRequired
  }, // end ShardConfig
})

Caching

> Note: if you create a CacheConfig you don't have to set every field.

> Note: Only LFU is supported.

> Note: Lifetime options does not currently work/do anything (yet).

A part of Disgord is the control you have; while this can be a good detail for advanced Users, we recommend beginners to utilise the default configurations (by simply not editing the configuration). Example of configuring the Cache:

 discord, err := disgord.NewClient(&disgord.Config{
   BotToken: "my-secret-bot-token",
   Cacher: &disgord.CacheConfig{
             Mutable: false, // everything going in and out of the Cache is deep copied
				// setting Mutable to true, might break your program as this is experimental and not supported.

             DisableUserCaching: false, // activates caching for Users
             UserCacheLifetime: time.Duration(4) * time.Hour, // removed from Cache after 9 hours, unless updated

             DisableVoiceStateCaching: true, // don't Cache voice states

             DisableChannelCaching: false,
             ChannelCacheLifetime: 0, // lives forever unless Cache replacement strategy kicks in
          },
 })

If you just want to change a specific field, you can do so. The fields are always default values.

> Note: Disabling caching for some types while activating it for others (eg. disabling Channels, but activating guild caching), can cause items extracted from the Cache to not reflect the true discord state.

Example, activated guild but disabled channel caching: The guild is stored to the Cache, but it's Channels are discarded. Guild Channels are dismantled from the guild object and otherwise stored in the channel Cache to improve performance and reduce memory use. So when you extract the cached guild object, all of the channel will only hold their channel ID, and nothing more.

Immutable Cache

To keep it safe and reliable, you can not directly affect the contents of the Cache. Unlike discordgo where everything is mutable, the caching in disgord is immutable. This does reduce performance as a copy must be made (only on new Cache entries), but as a performance freak, I can tell you right now that a simple struct copy is not that expensive. This also means that, as long as discord sends their events properly, the caching will always reflect the true state of discord.

If there is a bug in the Cache and you keep getting the incorrect data, please file an issue at github.com/andersfylling/disgord so it can quickly be resolved(!)

Bypass the built-in REST Cache

Whenever you call a REST method from the Session interface; the Cache is always checked first. Upon a Cache hit, no REST request is executed and you get the data from the Cache in return. However, if this is problematic for you or there exist a bug which gives you bad/outdated data, you can bypass it by using Disgord flags.

// get a user using the Session implementation (checks Cache, and updates the Cache on Cache miss)
user, err := session.GetUser(userID)

// bypass the Cache checking. Same as before, but we insert a disgord.Flag type.
user, err := session.GetUser(userID, disgord.IgnoreCache)

Disgord Flags

In addition to disgord.IgnoreCache, as shown above, you can pass in other flags such as: disgord.SortByID, disgord.OrderAscending, etc. You can find these flags in the flag.go file.

Build tags

`disgord_diagnosews` will store all the incoming and outgoing JSON data as files in the directory "diagnose-report/packets". The file format is as follows: unix_clientType_direction_shardID_operationCode_sequenceNumber[_eventName].json

`json_std` switches out jsoniter with the json package from the std libs.

`disgord_removeDiscordMutex` replaces mutexes in discord structures with a empty mutex; removes locking behaviour and any mutex code when compiled.

`disgord_parallelism` activates built-in locking in discord structure methods. Eg. Guild.AddChannel(*Channel) does not do locking by default. But if you find yourself using these discord data structures in parallel environment, you can activate the internal locking to reduce race conditions. Note that activating `disgord_parallelism` and `disgord_removeDiscordMutex` at the same time, will cause you to have no locking as `disgord_removeDiscordMutex` affects the same mutexes.

`disgord_legacy` adds wrapper methods with the original discord naming. eg. For REST requests you will notice Disgord uses a consistency between update/create/get/delete/set while discord uses edit/update/modify/close/delete/remove/etc. So if you struggle find a REST method, you can enable this build tag to gain access to mentioned wrappers.

`disgordperf` does some low level tweaking that can help boost json unmarshalling and drops json validation from Discord responses/events. Other optimizations might take place as well.

`disgord_websocket_gorilla` replaces nhooyr/websocket dependency with gorilla/websocket for gateway communication.

Deleting Discord data

In addition to the typical REST endpoints for deleting data, you can also use Client/Session.DeleteFromDiscord(...) for basic deletions. If you need to delete a specific range of messages, or anything complex as that; you can't use .DeleteFromDiscord(...). Not every struct has implemented the interface that allows you to call DeleteFromDiscord. Do not fret, if you try to pass a type that doesn't qualify, you get a compile error.

Index

Constants

View Source
const (
	NoCacheSpecified cacheRegistry = iota
	UserCache
	ChannelCache
	GuildCache
	GuildEmojiCache
	VoiceStateCache

	GuildMembersCache
	GuildRolesCache // warning: deletes previous roles
	GuildRoleCache  // updates or adds a new role
)

cacheLink keys to redirect to the related cacheLink system

View Source
const (
	ChannelTypeGuildText uint = iota
	ChannelTypeDM
	ChannelTypeGuildVoice
	ChannelTypeGroupDM
	ChannelTypeGuildCategory
	ChannelTypeGuildNews
	ChannelTypeGuildStore
)

Channel types https://discordapp.com/developers/docs/resources/channel#channel-object-channel-types

View Source
const (
	// GatewayCmdRequestGuildMembers Used to request offline members for a guild or
	// a list of Guilds. When initially connecting, the gateway will only send
	// offline members if a guild has less than the large_threshold members
	// (value in the Gateway Identify). If a Client wishes to receive additional
	// members, they need to explicitly request them via this operation. The
	// server will send Guild Members Chunk events in response with up to 1000
	// members per chunk until all members that match the request have been sent.
	RequestGuildMembers gatewayCmdName = cmd.RequestGuildMembers

	// UpdateVoiceState Sent when a Client wants to join, move, or
	// disconnect from a voice channel.
	UpdateVoiceState gatewayCmdName = cmd.UpdateVoiceState

	// UpdateStatus Sent by the Client to indicate a presence or status
	// update.
	UpdateStatus gatewayCmdName = cmd.UpdateStatus
)
View Source
const (
	StatusOnline  = string(gateway.StatusOnline)
	StatusOffline = string(gateway.StatusOffline)
	StatusDnd     = string(gateway.StatusDND)
	StatusIdle    = string(gateway.StatusIdle)
)

Constants for the different bit offsets of general permissions

View Source
const (
	MessageActivityTypeJoin
	MessageActivityTypeSpectate
	MessageActivityTypeListen
	MessageActivityTypeJoinRequest
)

different message acticity types

View Source
const (
	ActivityTypeGame acitivityType = iota
	ActivityTypeStreaming
	ActivityTypeListening

	ActivityTypeCustom
)
View Source
const (
	ActivityFlagInstance activityFlag = 1 << iota
	ActivityFlagJoin
	ActivityFlagSpectate
	ActivityFlagJoinRequest
	ActivityFlagSync
	ActivityFlagPlay
)

flags for the Activity object to signify the type of action taken place

View Source
const (
	AttachmentSpoilerPrefix = "SPOILER_"
)
View Source
const EvtChannelCreate = event.ChannelCreate

EvtChannelCreate Sent when a new channel is created, relevant to the current user. The inner payload is a DM channel or guild channel object.

View Source
const EvtChannelDelete = event.ChannelDelete

EvtChannelDelete Sent when a channel relevant to the current user is deleted. The inner payload is a DM or Guild channel object.

View Source
const EvtChannelPinsUpdate = event.ChannelPinsUpdate

EvtChannelPinsUpdate Sent when a message is pinned or unpinned in a text channel. This is not sent when a pinned message is deleted.

Fields:
- ChannelID int64 or Snowflake
- LastPinTimestamp time.Now().UTC().Format(time.RFC3339)

TODO fix.

View Source
const EvtChannelUpdate = event.ChannelUpdate

EvtChannelUpdate Sent when a channel is updated. The inner payload is a guild channel object.

View Source
const EvtGuildBanAdd = event.GuildBanAdd

EvtGuildBanAdd Sent when a user is banned from a guild. The inner payload is a user object, with an extra guild_id key.

View Source
const EvtGuildBanRemove = event.GuildBanRemove

EvtGuildBanRemove Sent when a user is unbanned from a guild. The inner payload is a user object, with an extra guild_id key.

View Source
const EvtGuildCreate = event.GuildCreate

EvtGuildCreate This event can be sent in three different scenarios:

 1. When a user is initially connecting, to lazily load and backfill information for all unavailable Guilds
    sent in the Ready event.
	2. When a Guild becomes available again to the client.
	3. When the current user joins a new Guild.
View Source
const EvtGuildDelete = event.GuildDelete

EvtGuildDelete Sent when a guild becomes unavailable during a guild outage, or when the user leaves or is removed from a guild. The inner payload is an unavailable guild object. If the unavailable field is not set, the user was removed from the guild.

View Source
const EvtGuildEmojisUpdate = event.GuildEmojisUpdate

EvtGuildEmojisUpdate Sent when a guild's emojis have been updated.

Fields:
- GuildID Snowflake
- Emojis []*Emoji
View Source
const EvtGuildIntegrationsUpdate = event.GuildIntegrationsUpdate

EvtGuildIntegrationsUpdate Sent when a guild integration is updated.

Fields:
- GuildID Snowflake
View Source
const EvtGuildMemberAdd = event.GuildMemberAdd

EvtGuildMemberAdd Sent when a new user joins a guild. The inner payload is a guild member object with these extra fields:

- GuildID Snowflake

Fields:
- Member *Member
View Source
const EvtGuildMemberRemove = event.GuildMemberRemove

EvtGuildMemberRemove Sent when a user is removed from a guild (leave/kick/ban).

Fields:
- GuildID   Snowflake
- User      *User
View Source
const EvtGuildMemberUpdate = event.GuildMemberUpdate

EvtGuildMemberUpdate Sent when a guild member is updated.

Fields:
- GuildID   Snowflake
- Roles     []Snowflake
- User      *User
- Nick      string
View Source
const EvtGuildMembersChunk = event.GuildMembersChunk

EvtGuildMembersChunk Sent in response to Gateway Request Guild Members.

Fields:
- GuildID Snowflake
- Members []*Member
View Source
const EvtGuildRoleCreate = event.GuildRoleCreate

EvtGuildRoleCreate Sent when a guild role is created.

Fields:
- GuildID   Snowflake
- Role      *Role
View Source
const EvtGuildRoleDelete = event.GuildRoleDelete

EvtGuildRoleDelete Sent when a guild role is created.

Fields:
- GuildID Snowflake
- RoleID  Snowflake
View Source
const EvtGuildRoleUpdate = event.GuildRoleUpdate

EvtGuildRoleUpdate Sent when a guild role is created.

Fields:
- GuildID Snowflake
- Role    *Role
View Source
const EvtGuildUpdate = event.GuildUpdate

EvtGuildUpdate Sent when a guild is updated. The inner payload is a guild object.

View Source
const EvtMessageCreate = event.MessageCreate

EvtMessageCreate Sent when a message is created. The inner payload is a message object.

View Source
const EvtMessageDelete = event.MessageDelete

EvtMessageDelete Sent when a message is deleted.

Fields:
- ID        Snowflake
- ChannelID Snowflake
View Source
const EvtMessageDeleteBulk = event.MessageDeleteBulk

EvtMessageDeleteBulk Sent when multiple messages are deleted at once.

Fields:
- IDs       []Snowflake
- ChannelID Snowflake
View Source
const EvtMessageReactionAdd = event.MessageReactionAdd

EvtMessageReactionAdd Sent when a user adds a reaction to a message.

Fields:
- UserID     Snowflake
- ChannelID  Snowflake
- MessageID  Snowflake
- Emoji      *Emoji
View Source
const EvtMessageReactionRemove = event.MessageReactionRemove

EvtMessageReactionRemove Sent when a user removes a reaction from a message.

Fields:
- UserID     Snowflake
- ChannelID  Snowflake
- MessageID  Snowflake
- Emoji      *Emoji
View Source
const EvtMessageReactionRemoveAll = event.MessageReactionRemoveAll

EvtMessageReactionRemoveAll Sent when a user explicitly removes all reactions from a message.

Fields:
- ChannelID Snowflake
- MessageID Snowflake
View Source
const EvtMessageUpdate = event.MessageUpdate

EvtMessageUpdate Sent when a message is updated. The inner payload is a message object.

NOTE! Has _at_least_ the GuildID and ChannelID fields.

View Source
const EvtPresenceUpdate = event.PresenceUpdate

EvtPresenceUpdate A user's presence is their current state on a guild. This event is sent when a user's presence is updated for a guild.

Fields:
- User    *User
- Roles   []Snowflake
- Game    *Activity
- GuildID Snowflake
- Status  string
View Source
const EvtReady = event.Ready

EvtReady The ready event is dispatched when a client has completed the initial handshake with the gateway (for new sessions). // The ready event can be the largest and most complex event the gateway will send, as it contains all the state // required for a client to begin interacting with the rest of the platform. // Fields: // - V int // - User *User // - PrivateChannels []*Channel // - Guilds []*GuildUnavailable // - SessionID string // - Trace []string

View Source
const EvtResumed = event.Resumed

EvtResumed The resumed event is dispatched when a client has sent a resume payload to the gateway (for resuming existing sessions).

Fields:
- Trace []string
View Source
const EvtTypingStart = event.TypingStart

EvtTypingStart Sent when a user starts typing in a channel.

Fields:
- ChannelID     Snowflake
- UserID        Snowflake
- TimestampUnix int
View Source
const EvtUserUpdate = event.UserUpdate

EvtUserUpdate Sent when properties about the user change. Inner payload is a user object.

View Source
const EvtVoiceServerUpdate = event.VoiceServerUpdate

EvtVoiceServerUpdate Sent when a guild's voice server is updated. This is sent when initially connecting to voice, and when the current voice instance fails over to a new server.

Fields:
- Token     string
- ChannelID Snowflake
- Endpoint  string
View Source
const EvtVoiceStateUpdate = event.VoiceStateUpdate

EvtVoiceStateUpdate Sent when someone joins/leaves/moves voice Channels. Inner payload is a voice state object.

View Source
const EvtWebhooksUpdate = event.WebhooksUpdate

EvtWebhooksUpdate Sent when a guild channel's WebHook is created, updated, or deleted.

Fields:
- GuildID   Snowflake
- ChannelID Snowflake
View Source
const Name = constant.Name
View Source
const Version = constant.Version

Variables

This section is empty.

Functions

func AllEvents

func AllEvents(except ...string) []string

func CreateTermSigListener

func CreateTermSigListener() <-chan os.Signal

CreateTermSigListener create a channel to listen for termination signals (graceful shutdown)

func DefaultLogger

func DefaultLogger(debug bool) *logger.LoggerZap

func DefaultLoggerWithInstance

func DefaultLoggerWithInstance(log *zap.Logger) *logger.LoggerZap

func LibraryInfo

func LibraryInfo() string

LibraryInfo returns name + version

func ShardID

func ShardID(guildID Snowflake, nrOfShards uint) uint

ShardID calculate the shard id for a given guild. https://discordapp.com/developers/docs/topics/gateway#sharding-sharding-formula

func Sort

func Sort(v interface{}, fs ...Flag)

func SortRoles

func SortRoles(rs []*Role)

SortRoles sorts a slice of roles such that the first element is the top one in the Discord Guild Settings UI.

func ValidateHandlerInputs

func ValidateHandlerInputs(inputs ...interface{}) (err error)

func ValidateUsername

func ValidateUsername(name string) (err error)

ValidateUsername uses Discords rule-set to verify user-names and nicknames https://discordapp.com/developers/docs/resources/user#usernames-and-nicknames

Note that not all the rules are listed in the docs:

There are other rules and restrictions not shared here for the sake of spam and abuse mitigation, but the
majority of Users won't encounter them. It's important to properly handle all error messages returned by
Discord when editing or updating names.

Types

type Activity

type Activity struct {
	Lockable `json:"-"`

	Name          string             `json:"name"`                     // the activity's name
	Type          acitivityType      `json:"type"`                     // activity type
	URL           string             `json:"url,omitempty"`            //stream url, is validated when type is 1
	Timestamps    *ActivityTimestamp `json:"timestamps,omitempty"`     // timestamps object	unix timestamps for start and/or end of the game
	ApplicationID Snowflake          `json:"application_id,omitempty"` //?	snowflake	application id for the game
	Details       string             `json:"details,omitempty"`        //?	?string	what the player is currently doing
	State         string             `json:"state,omitempty"`          //state?	?string	the user's current party status
	Emoji         *ActivityEmoji     `json:"emoji"`
	Party         *ActivityParty     `json:"party,omitempty"`    //party?	party object	information for the current party of the player
	Assets        *ActivityAssets    `json:"assets,omitempty"`   // assets?	assets object	images for the presence and their hover texts
	Secrets       *ActivitySecrets   `json:"secrets,omitempty"`  // secrets?	secrets object	secrets for Rich Presence joining and spectating
	Instance      bool               `json:"instance,omitempty"` // instance?	boolean	whether or not the activity is an instanced game session
	Flags         activityFlag       `json:"flags,omitempty"`    // flags?	int	activity flags ORd together, describes what the payload includes
}

Activity https://discordapp.com/developers/docs/topics/gateway#activity-object-activity-structure

func NewActivity

func NewActivity() (activity *Activity)

NewActivity ...

func (*Activity) CopyOverTo

func (a *Activity) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Activity) DeepCopy

func (a *Activity) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*Activity) Reset

func (a *Activity) Reset()

type ActivityAssets

type ActivityAssets struct {
	Lockable `json:"-"`

	LargeImage string `json:"large_image,omitempty"` // the id for a large asset of the activity, usually a snowflake
	LargeText  string `json:"large_text,omitempty"`  //text displayed when hovering over the large image of the activity
	SmallImage string `json:"small_image,omitempty"` // the id for a small asset of the activity, usually a snowflake
	SmallText  string `json:"small_text,omitempty"`  //	text displayed when hovering over the small image of the activity
}

ActivityAssets ...

func (*ActivityAssets) CopyOverTo

func (a *ActivityAssets) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*ActivityAssets) DeepCopy

func (a *ActivityAssets) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type ActivityEmoji

type ActivityEmoji struct {
	Lockable `json:"-"`

	Name     string    `json:"name"`
	ID       Snowflake `json:"id,omitempty"`
	Animated bool      `json:"animated,omitempty"`
}

ActivityEmoji ...

type ActivityParty

type ActivityParty struct {
	Lockable `json:"-"`

	ID   string `json:"id,omitempty"`   // the id of the party
	Size []int  `json:"size,omitempty"` // used to show the party's current and maximum size
}

ActivityParty ...

func (*ActivityParty) CopyOverTo

func (ap *ActivityParty) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*ActivityParty) DeepCopy

func (ap *ActivityParty) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*ActivityParty) Limit

func (ap *ActivityParty) Limit() int

Limit shows the maximum number of guests/people allowed

func (*ActivityParty) NumberOfPeople

func (ap *ActivityParty) NumberOfPeople() int

NumberOfPeople shows the current number of people attending the Party

type ActivitySecrets

type ActivitySecrets struct {
	Lockable `json:"-"`

	Join     string `json:"join,omitempty"`     // the secret for joining a party
	Spectate string `json:"spectate,omitempty"` // the secret for spectating a game
	Match    string `json:"match,omitempty"`    // the secret for a specific instanced match
}

ActivitySecrets ...

func (*ActivitySecrets) CopyOverTo

func (a *ActivitySecrets) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*ActivitySecrets) DeepCopy

func (a *ActivitySecrets) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type ActivityTimestamp

type ActivityTimestamp struct {
	Lockable `json:"-"`

	Start int `json:"start,omitempty"` // unix time (in milliseconds) of when the activity started
	End   int `json:"end,omitempty"`   // unix time (in milliseconds) of when the activity ends
}

ActivityTimestamp ...

func (*ActivityTimestamp) CopyOverTo

func (a *ActivityTimestamp) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*ActivityTimestamp) DeepCopy

func (a *ActivityTimestamp) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type AddGuildMemberParams

type AddGuildMemberParams struct {
	AccessToken string      `json:"access_token"` // required
	Nick        string      `json:"nick,omitempty"`
	Roles       []Snowflake `json:"roles,omitempty"`
	Mute        bool        `json:"mute,omitempty"`
	Deaf        bool        `json:"deaf,omitempty"`
}

AddGuildMemberParams ... https://discordapp.com/developers/docs/resources/guild#add-guild-member-json-params

type Attachment

type Attachment struct {
	ID       Snowflake `json:"id"`
	Filename string    `json:"filename"`
	Size     uint      `json:"size"`
	URL      string    `json:"url"`
	ProxyURL string    `json:"proxy_url"`
	Height   uint      `json:"height"`
	Width    uint      `json:"width"`

	SpoilerTag bool `json:"-"`
}

Attachment https://discordapp.com/developers/docs/resources/channel#attachment-object

func (*Attachment) DeepCopy

func (a *Attachment) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type AuditLog

type AuditLog struct {
	Lockable `json:"-"`

	Webhooks        []*Webhook       `json:"webhooks"`
	Users           []*User          `json:"Users"`
	AuditLogEntries []*AuditLogEntry `json:"audit_log_entries"`
}

AuditLog ...

func (*AuditLog) Bans

func (l *AuditLog) Bans() (bans []*PartialBan)

func (*AuditLog) CopyOverTo

func (l *AuditLog) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*AuditLog) DeepCopy

func (l *AuditLog) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type AuditLogChange

type AuditLogChange string
const (
	// key name,								          identifier                       changed, type,   description
	AuditLogChangeName                        AuditLogChange = "name"                          // guild	string	name changed
	AuditLogChangeIconHash                    AuditLogChange = "icon_hash"                     // guild	string	icon changed
	AuditLogChangeSplashHash                  AuditLogChange = "splash_hash"                   // guild	string	invite splash page artwork changed
	AuditLogChangeOwnerID                     AuditLogChange = "owner_id"                      // guild	snowflake	owner changed
	AuditLogChangeRegion                      AuditLogChange = "region"                        // guild	string	region changed
	AuditLogChangeAFKChannelID                AuditLogChange = "afk_channel_id"                // guild	snowflake	afk channel changed
	AuditLogChangeAFKTimeout                  AuditLogChange = "afk_timeout"                   // guild	integer	afk timeout duration changed
	AuditLogChangeMFALevel                    AuditLogChange = "mfa_level"                     // guild	integer	two-factor auth requirement changed
	AuditLogChangeVerificationLevel           AuditLogChange = "verification_level"            // guild	integer	required verification level changed
	AuditLogChangeExplicitContentFilter       AuditLogChange = "explicit_content_filter"       // guild	integer	change in whose messages are scanned and deleted for explicit content in the server
	AuditLogChangeDefaultMessageNotifications AuditLogChange = "default_message_notifications" // guild	integer	default message notification level changed
	AuditLogChangeVanityURLCode               AuditLogChange = "vanity_url_code"               // guild	string	guild invite vanity url changed
	AuditLogChangeAdd                         AuditLogChange = "$add"                          // add	guild	array of role objects	new role added
	AuditLogChangeRemove                      AuditLogChange = "$remove"                       // remove	guild	array of role objects	role removed
	AuditLogChangePruneDeleteDays             AuditLogChange = "prune_delete_days"             // guild	integer	change in number of days after which inactive and role-unassigned members are kicked
	AuditLogChangeWidgetEnabled               AuditLogChange = "widget_enabled"                // guild	bool	server widget enabled/disable
	AuditLogChangeWidgetChannelID             AuditLogChange = "widget_channel_id"             // guild	snowflake	channel id of the server widget changed
	AuditLogChangePosition                    AuditLogChange = "position"                      // channel	integer	text or voice channel position changed
	AuditLogChangeTopic                       AuditLogChange = "topic"                         // channel	string	text channel topic changed
	AuditLogChangeBitrate                     AuditLogChange = "bitrate"                       // channel	integer	voice channel bitrate changed
	AuditLogChangePermissionOverwrites        AuditLogChange = "permission_overwrites"         // channel	array of channel overwrite objects	permissions on a channel changed
	AuditLogChangeNSFW                        AuditLogChange = "nsfw"                          // channel	bool	channel nsfw restriction changed
	AuditLogChangeApplicationID               AuditLogChange = "application_id"                // channel	snowflake	application id of the added or removed webhook or bot
	AuditLogChangePermissions                 AuditLogChange = "permissions"                   // role	integer	permissions for a role changed
	AuditLogChangeColor                       AuditLogChange = "color"                         // role	integer	role color changed
	AuditLogChangeHoist                       AuditLogChange = "hoist"                         // role	bool	role is now displayed/no longer displayed separate from online Users
	AuditLogChangeMentionable                 AuditLogChange = "mentionable"                   // role	bool	role is now mentionable/unmentionable
	AuditLogChangeAllow                       AuditLogChange = "allow"                         // role	integer	a permission on a text or voice channel was allowed for a role
	AuditLogChangeDeny                        AuditLogChange = "deny"                          // role	integer	a permission on a text or voice channel was denied for a role
	AuditLogChangeCode                        AuditLogChange = "code"                          // invite	string	invite code changed
	AuditLogChangeChannelID                   AuditLogChange = "channel_id"                    // invite	snowflake	channel for invite code changed
	AuditLogChangeInviterID                   AuditLogChange = "inviter_id"                    // invite	snowflake	person who created invite code changed
	AuditLogChangeMaxUses                     AuditLogChange = "max_uses"                      // invite	integer	change to max number of times invite code can be used
	AuditLogChangeUses                        AuditLogChange = "uses"                          // invite	integer	number of times invite code used changed
	AuditLogChangeMaxAge                      AuditLogChange = "max_age"                       // invite	integer	how long invite code lasts changed
	AuditLogChangeTemporary                   AuditLogChange = "temporary"                     // invite	bool	invite code is temporary/never expires
	AuditLogChangeDeaf                        AuditLogChange = "deaf"                          // user	bool	user server deafened/undeafened
	AuditLogChangeMute                        AuditLogChange = "mute"                          // user	bool	user server muted/unmuteds
	AuditLogChangeNick                        AuditLogChange = "nick"                          // user	string	user nickname changed
	AuditLogChangeAvatarHash                  AuditLogChange = "avatar_hash"                   // user	string	user avatar changed
	AuditLogChangeID                          AuditLogChange = "id"                            // any	snowflake	the id of the changed entity - sometimes used in conjunction with other keys
	AuditLogChangeType                        AuditLogChange = "type"                          // any	integer (channel type) or string	type of entity created
)

all the different keys for an audit log change

type AuditLogChanges

type AuditLogChanges struct {
	Lockable `json:"-"`

	NewValue interface{} `json:"new_value,omitempty"`
	OldValue interface{} `json:"old_value,omitempty"`
	Key      string      `json:"key"`
}

AuditLogChanges ...

func (*AuditLogChanges) CopyOverTo

func (l *AuditLogChanges) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*AuditLogChanges) DeepCopy

func (l *AuditLogChanges) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type AuditLogEntry

type AuditLogEntry struct {
	Lockable `json:"-"`

	TargetID Snowflake          `json:"target_id"`
	Changes  []*AuditLogChanges `json:"changes,omitempty"`
	UserID   Snowflake          `json:"user_id"`
	ID       Snowflake          `json:"id"`
	Event    AuditLogEvt        `json:"action_type"`
	Options  *AuditLogOption    `json:"options,omitempty"`
	Reason   string             `json:"reason,omitempty"`
}

AuditLogEntry ...

func (*AuditLogEntry) CopyOverTo

func (l *AuditLogEntry) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*AuditLogEntry) DeepCopy

func (l *AuditLogEntry) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type AuditLogEvt

type AuditLogEvt uint
const (
	AuditLogEvtChannelCreate AuditLogEvt = 10 + iota
	AuditLogEvtChannelUpdate
	AuditLogEvtChannelDelete
	AuditLogEvtOverwriteCreate
	AuditLogEvtOverwriteUpdate
	AuditLogEvtOverwriteDelete
)
const (
	AuditLogEvtMemberKick AuditLogEvt = 20 + iota
	AuditLogEvtMemberPrune
	AuditLogEvtMemberBanAdd
	AuditLogEvtMemberBanRemove
	AuditLogEvtMemberUpdate
	AuditLogEvtMemberRoleUpdate
)
const (
	AuditLogEvtRoleCreate AuditLogEvt = 30 + iota
	AuditLogEvtRoleUpdate
	AuditLogEvtRoleDelete
)
const (
	AuditLogEvtInviteCreate AuditLogEvt = 40
	AuditLogEvtInviteUpdate
	AuditLogEvtInviteDelete
)
const (
	AuditLogEvtWebhookCreate AuditLogEvt = 50 + iota
	AuditLogEvtWebhookUpdate
	AuditLogEvtWebhookDelete
)
const (
	AuditLogEvtEmojiCreate AuditLogEvt = 60 + iota
	AuditLogEvtEmojiUpdate
	AuditLogEvtEmojiDelete
)
const (
	AuditLogEvtGuildUpdate AuditLogEvt = 1
)

Audit-log event types

const (
	AuditLogEvtMessageDelete AuditLogEvt = 72
)

type AuditLogOption

type AuditLogOption struct {
	Lockable `json:"-"`

	DeleteMemberDays string    `json:"delete_member_days"`
	MembersRemoved   string    `json:"members_removed"`
	ChannelID        Snowflake `json:"channel_id"`
	Count            string    `json:"count"`
	ID               Snowflake `json:"id"`
	Type             string    `json:"type"` // type of overwritten entity ("member" or "role")
	RoleName         string    `json:"role_name"`
}

AuditLogOption ...

func (*AuditLogOption) CopyOverTo

func (l *AuditLogOption) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*AuditLogOption) DeepCopy

func (l *AuditLogOption) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type AvatarParamHolder

type AvatarParamHolder interface {
	json.Marshaler
	Empty() bool
	SetAvatar(avatar string)
	UseDefaultAvatar()
}

AvatarParamHolder is used when handling avatar related REST structs. since a Avatar can be reset by using nil, it causes some extra issues as omit empty cannot be used to get around this, the struct requires an internal state and must also handle custom marshalling

type Ban

type Ban struct {
	Lockable `json:"-"`

	Reason string `json:"reason"`
	User   *User  `json:"user"`
}

Ban https://discordapp.com/developers/docs/resources/guild#ban-object

func (*Ban) CopyOverTo

func (b *Ban) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Ban) DeepCopy

func (b *Ban) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type BanMemberParams

type BanMemberParams struct {
	DeleteMessageDays int    `urlparam:"delete_message_days,omitempty"` // number of days to delete messages for (0-7)
	Reason            string `urlparam:"reason,omitempty"`              // reason for being banned
}

BanMemberParams ... https://discordapp.com/developers/docs/resources/guild#create-guild-ban-query-string-params

func (*BanMemberParams) FindErrors

func (b *BanMemberParams) FindErrors() error

func (*BanMemberParams) URLQueryString

func (b *BanMemberParams) URLQueryString() string

type BodyUserCreateDM

type BodyUserCreateDM struct {
	RecipientID Snowflake `json:"recipient_id"`
}

BodyUserCreateDM JSON param for func CreateDM

type Cache

type Cache struct {
	Users       *crs.LFU
	VoiceStates *crs.LFU
	Channels    *crs.LFU
	Guilds      *crs.LFU
	// contains filtered or unexported fields
}

Cacher is the actual cacheLink. It holds the different systems which can be tweaked using the CacheConfig.

func (*Cache) AddGuildChannel

func (c *Cache) AddGuildChannel(guildID Snowflake, channelID Snowflake)

func (*Cache) AddGuildMember

func (c *Cache) AddGuildMember(guildID Snowflake, member *Member)

func (*Cache) AddGuildRole

func (c *Cache) AddGuildRole(guildID Snowflake, role *Role)

func (*Cache) DeleteChannel

func (c *Cache) DeleteChannel(id Snowflake)

DeleteChannel ...

func (*Cache) DeleteChannelPermissionOverwrite

func (c *Cache) DeleteChannelPermissionOverwrite(channelID Snowflake, overwriteID Snowflake) error

func (*Cache) DeleteGuild

func (c *Cache) DeleteGuild(id Snowflake)

DeleteGuild ...

func (*Cache) DeleteGuildChannel

func (c *Cache) DeleteGuildChannel(guildID, channelID Snowflake)

DeleteGuildChannel removes a channel from a cached guild object without removing the guild

func (*Cache) DeleteGuildEmoji

func (c *Cache) DeleteGuildEmoji(guildID, emojiID Snowflake)

func (*Cache) DeleteGuildRole

func (c *Cache) DeleteGuildRole(guildID, roleID Snowflake)

DeleteGuildRole removes a role from a cached guild object without removing the guild

func (*Cache) DirectUpdate

func (c *Cache) DirectUpdate(registry cacheRegistry, id Snowflake, changes []byte) error

DirectUpdate is used for socket events to only update provided fields. Will peek into the cacheLink for a matching entry if found it updates it, otherwise a not found error is returned. May return a unmarshal error.

// user update
id := extractAttribute([]byte(`"id":"`), 0, jsonData)
err := cacheLink.DirectUpdate(UserCache, id, jsonData)
if err != nil {
	// most likely the user does not exist or it could not be updated
	// add the new user. See Cacher.Update
}

TODO-optimize: for bulk changes

func (*Cache) Get

func (c *Cache) Get(key cacheRegistry, id Snowflake, args ...interface{}) (v interface{}, err error)

Get retrieve a item in the cacheLink, or get an error when not found or if the cacheLink system is disabled in your CacheConfig configuration.

func (*Cache) GetChannel

func (c *Cache) GetChannel(id Snowflake) (channel *Channel, err error)

GetChannel ...

func (*Cache) GetGuild

func (c *Cache) GetGuild(id Snowflake) (guild *Guild, err error)

GetGuild ...

func (*Cache) GetGuildEmojis

func (c *Cache) GetGuildEmojis(id Snowflake) (emojis []*Emoji, err error)

GetGuildRoles ...

func (*Cache) GetGuildMember

func (c *Cache) GetGuildMember(guildID, userID Snowflake) (member *Member, err error)

GetGuildMember ...

func (*Cache) GetGuildMembersAfter

func (c *Cache) GetGuildMembersAfter(guildID, after Snowflake, limit int) (members []*Member, err error)

GetGuildMembersAfter ...

func (*Cache) GetGuildRoles

func (c *Cache) GetGuildRoles(id Snowflake) (roles []*Role, err error)

GetGuildRoles ...

func (*Cache) GetUser

func (c *Cache) GetUser(id Snowflake) (user *User, err error)

GetUser ...

func (*Cache) GetVoiceState

func (c *Cache) GetVoiceState(guildID Snowflake, params *guildVoiceStateCacheParams) (state *VoiceState, err error)

GetVoiceState ...

func (*Cache) PeekGuild

func (c *Cache) PeekGuild(id Snowflake) (guild *Guild, err error)

func (*Cache) PeekUser

func (c *Cache) PeekUser(id Snowflake) (*User, error)

func (*Cache) RemoveGuildMember

func (c *Cache) RemoveGuildMember(guildID Snowflake, memberID Snowflake)

func (*Cache) SetChannel

func (c *Cache) SetChannel(new *Channel)

SetChannel adds a new channel to cacheLink or updates an existing one

func (*Cache) SetGuild

func (c *Cache) SetGuild(guild *Guild)

SetGuild adds a new guild to cacheLink or updates an existing one

func (*Cache) SetGuildEmojis

func (c *Cache) SetGuildEmojis(guildID Snowflake, emojis []*Emoji)

SetGuildEmojis adds a new guild to cacheLink if no guild exist for the emojis or updates an existing guild with the new emojis

func (*Cache) SetGuildMember

func (c *Cache) SetGuildMember(guildID Snowflake, member *Member)

SetGuildMember calls SetGuildMembers

func (*Cache) SetGuildMembers

func (c *Cache) SetGuildMembers(guildID Snowflake, members []*Member)

SetGuildMembers adds the members to a guild or updates an existing guild

func (*Cache) SetGuildRoles

func (c *Cache) SetGuildRoles(guildID Snowflake, roles []*Role)

SetGuildRoles creates a new guild if none is found and updates the roles for a given guild

func (*Cache) SetUser

func (c *Cache) SetUser(new *User)

SetUser updates an existing user or adds a new one to the cacheLink

func (*Cache) SetVoiceState

func (c *Cache) SetVoiceState(state *VoiceState)

SetVoiceState adds a new voice state to cacheLink or updates an existing one

func (*Cache) Update

func (c *Cache) Update(key cacheRegistry, v interface{}) (err error)

Update updates a item in the cacheLink given the key identifier and the new content. It also checks if the given structs implements the required interfaces (See below).

func (*Cache) UpdateChannelLastMessageID

func (c *Cache) UpdateChannelLastMessageID(channelID Snowflake, messageID Snowflake)

UpdateChannelLastMessageID ...

func (*Cache) UpdateChannelPin

func (c *Cache) UpdateChannelPin(id Snowflake, timestamp Time)

UpdateChannelPin ...

func (*Cache) UpdateGuildRole

func (c *Cache) UpdateGuildRole(guildID Snowflake, role *Role, data json.RawMessage) bool

func (*Cache) UpdateMemberAndUser

func (c *Cache) UpdateMemberAndUser(guildID, userID Snowflake, data json.RawMessage)

func (*Cache) UpdateOrAddGuildMembers

func (c *Cache) UpdateOrAddGuildMembers(guildID Snowflake, members []*Member)

UpdateOrAddGuildMembers updates and add new members to the guild. It discards the user object so these must be handled before hand. complexity: O(M * N)

func (*Cache) Updates

func (c *Cache) Updates(key cacheRegistry, vs []interface{}) (err error)

Updates does the same as Update. But allows for a slice of entries instead.

type CacheConfig

type CacheConfig struct {
	Mutable bool // Must be immutable to support concurrent access and long-running tasks(!)

	DisableUserCaching  bool
	UserCacheMaxEntries uint
	UserCacheLifetime   time.Duration

	DisableVoiceStateCaching  bool
	VoiceStateCacheMaxEntries uint
	VoiceStateCacheLifetime   time.Duration

	DisableChannelCaching  bool
	ChannelCacheMaxEntries uint
	ChannelCacheLifetime   time.Duration

	DisableGuildCaching  bool
	GuildCacheMaxEntries uint
	GuildCacheLifetime   time.Duration

	// Deprecated
	UserCacheAlgorithm string
	// Deprecated
	VoiceStateCacheAlgorithm string
	// Deprecated
	ChannelCacheAlgorithm string
	// Deprecated
	GuildCacheAlgorithm string
}

CacheConfig allows for tweaking the cacheLink system on a personal need

type Cacher

type Cacher interface {
	Update(key cacheRegistry, v interface{}) (err error)
	Get(key cacheRegistry, id Snowflake, args ...interface{}) (v interface{}, err error)
	DeleteChannel(channelID Snowflake)
	DeleteGuildChannel(guildID Snowflake, channelID Snowflake)
	AddGuildChannel(guildID Snowflake, channelID Snowflake)
	AddGuildMember(guildID Snowflake, member *Member)
	RemoveGuildMember(guildID Snowflake, memberID Snowflake)
	UpdateChannelPin(channelID Snowflake, lastPinTimestamp Time)
	UpdateMemberAndUser(guildID, userID Snowflake, data json.RawMessage)
	DeleteGuild(guildID Snowflake)
	DeleteGuildRole(guildID Snowflake, roleID Snowflake)
	UpdateChannelLastMessageID(channelID Snowflake, messageID Snowflake)
	SetGuildEmojis(guildID Snowflake, emojis []*Emoji)
	Updates(key cacheRegistry, vs []interface{}) error
	AddGuildRole(guildID Snowflake, role *Role)
	UpdateGuildRole(guildID Snowflake, role *Role, messages json.RawMessage) bool
}

Cacher gives basic cacheLink interaction options, and won't require changes when adding more cacheLink systems

type Channel

type Channel struct {
	Lockable             `json:"-"`
	ID                   Snowflake             `json:"id"`
	Type                 uint                  `json:"type"`
	GuildID              Snowflake             `json:"guild_id,omitempty"`              // ?|
	Position             int                   `json:"position,omitempty"`              // ?| can be less than 0
	PermissionOverwrites []PermissionOverwrite `json:"permission_overwrites,omitempty"` // ?|
	Name                 string                `json:"name,omitempty"`                  // ?|
	Topic                string                `json:"topic,omitempty"`                 // ?|?
	NSFW                 bool                  `json:"nsfw,omitempty"`                  // ?|
	LastMessageID        Snowflake             `json:"last_message_id,omitempty"`       // ?|?
	Bitrate              uint                  `json:"bitrate,omitempty"`               // ?|
	UserLimit            uint                  `json:"user_limit,omitempty"`            // ?|
	RateLimitPerUser     uint                  `json:"rate_limit_per_user,omitempty"`   // ?|
	Recipients           []*User               `json:"recipient,omitempty"`             // ?| , empty if not DM/GroupDM
	Icon                 string                `json:"icon,omitempty"`                  // ?|?
	OwnerID              Snowflake             `json:"owner_id,omitempty"`              // ?|
	ApplicationID        Snowflake             `json:"application_id,omitempty"`        // ?|
	ParentID             Snowflake             `json:"parent_id,omitempty"`             // ?|?
	LastPinTimestamp     Time                  `json:"last_pin_timestamp,omitempty"`    // ?|
	// contains filtered or unexported fields
}

Channel ...

func NewChannel

func NewChannel() *Channel

NewChannel ...

func (*Channel) Compare

func (c *Channel) Compare(other *Channel) bool

Compare checks if channel A is the same as channel B

func (*Channel) CopyOverTo

func (c *Channel) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Channel) DeepCopy

func (c *Channel) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*Channel) Mention

func (c *Channel) Mention() string

Mention creates a channel mention string. Mention format is according the Discord protocol.

func (*Channel) Reset

func (c *Channel) Reset()

func (*Channel) SendMsg

func (c *Channel) SendMsg(ctx context.Context, client MessageSender, message *Message) (msg *Message, err error)

SendMsg sends a message to a channel

func (*Channel) SendMsgString

func (c *Channel) SendMsgString(ctx context.Context, client MessageSender, content string) (msg *Message, err error)

SendMsgString same as SendMsg, however this only takes the message content (string) as a argument for the message

func (*Channel) String

func (c *Channel) String() string

type ChannelCreate

type ChannelCreate struct {
	Channel *Channel        `json:"channel"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

ChannelCreate new channel created

func (*ChannelCreate) UnmarshalJSON

func (obj *ChannelCreate) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type ChannelCreateHandler

type ChannelCreateHandler = func(s Session, h *ChannelCreate)

ChannelCreateHandler is triggered in ChannelCreate events

type ChannelDelete

type ChannelDelete struct {
	Channel *Channel        `json:"channel"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

ChannelDelete channel was deleted

func (*ChannelDelete) UnmarshalJSON

func (obj *ChannelDelete) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type ChannelDeleteHandler

type ChannelDeleteHandler = func(s Session, h *ChannelDelete)

ChannelDeleteHandler is triggered in ChannelDelete events

type ChannelFetcher

type ChannelFetcher interface {
	GetChannel(id Snowflake) (ret *Channel, err error)
}

ChannelFetcher holds the single method for fetching a channel from the Discord REST API

type ChannelPinsUpdate

type ChannelPinsUpdate struct {
	// ChannelID snowflake	the id of the channel
	ChannelID Snowflake `json:"channel_id"`

	// LastPinTimestamp	ISO8601 timestamp	the time at which the most recent pinned message was pinned
	LastPinTimestamp Time            `json:"last_pin_timestamp,omitempty"` // ?|
	Ctx              context.Context `json:"-"`
	ShardID          uint            `json:"-"`
}

ChannelPinsUpdate message was pinned or unpinned

type ChannelPinsUpdateHandler

type ChannelPinsUpdateHandler = func(s Session, h *ChannelPinsUpdate)

ChannelPinsUpdateHandler is triggered in ChannelPinsUpdate events

type ChannelUpdate

type ChannelUpdate struct {
	Channel *Channel        `json:"channel"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

ChannelUpdate channel was updated

func (*ChannelUpdate) UnmarshalJSON

func (obj *ChannelUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type ChannelUpdateHandler

type ChannelUpdateHandler = func(s Session, h *ChannelUpdate)

ChannelUpdateHandler is triggered in ChannelUpdate events

type Client

type Client struct {
	sync.RWMutex

	Cache *Cache
	// contains filtered or unexported fields
}

Client is the main disgord Client to hold your state and data. You must always initiate it using the constructor methods (eg. New(..) or NewClient(..)).

Note that this Client holds all the REST methods, and is split across files, into whatever category the REST methods regards.

func New

func New(conf Config) *Client

New create a Client. But panics on configuration/setup errors.

func NewClient

func NewClient(conf Config) (*Client, error)

NewClient creates a new Disgord Client and returns an error on configuration issues

func (*Client) AddDMParticipant

func (c *Client) AddDMParticipant(ctx context.Context, channelID Snowflake, participant *GroupDMParticipant, flags ...Flag) error

AddDMParticipant [REST] Adds a recipient to a Group DM using their access token. Returns a 204 empty response on success.

Method                  PUT
Endpoint                /Channels/{channel.id}/recipients/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#group-dm-add-recipient
Reviewed                2018-06-10
Comment                 -

func (*Client) AddGuildMember

func (c *Client) AddGuildMember(ctx context.Context, guildID, userID Snowflake, accessToken string, params *AddGuildMemberParams, flags ...Flag) (member *Member, err error)

AddGuildMember [REST] Adds a user to the guild, provided you have a valid oauth2 access token for the user with the Guilds.join scope. Returns a 201 Created with the guild member as the body, or 204 No Content if the user is already a member of the guild. Fires a Guild Member Add Gateway event. Requires the bot to have the CREATE_INSTANT_INVITE permission.

Method                  PUT
Endpoint                /Guilds/{guild.id}/members/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#add-guild-member
Reviewed                2018-08-18
Comment                 All parameters to this endpoint. except for access_token are optional.

func (*Client) AddGuildMemberRole

func (c *Client) AddGuildMemberRole(ctx context.Context, guildID, userID, roleID Snowflake, flags ...Flag) (err error)

AddGuildMemberRole [REST] Adds a role to a guild member. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success. Fires a Guild Member Update Gateway event.

Method                  PUT
Endpoint                /Guilds/{guild.id}/members/{user.id}/roles/{role.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#add-guild-member-role
Reviewed                2018-08-18
Comment                 -

func (*Client) AddPermission

func (c *Client) AddPermission(permission PermissionBit) (updatedPermissions PermissionBits)

AddPermission adds a minimum required permission to the bot. If the permission is negative, it is overwritten to 0. This is useful for creating the bot URL.

At the moment, this holds no other effect than aesthetics.

func (*Client) AvgHeartbeatLatency

func (c *Client) AvgHeartbeatLatency() (duration time.Duration, err error)

AvgHeartbeatLatency checks the duration of waiting before receiving a response from Discord when a heartbeat packet was sent. Note that heartbeats are usually sent around once a minute and is not a accurate way to measure delay between the Client and Discord server

func (*Client) BanMember

func (c *Client) BanMember(ctx context.Context, guildID, userID Snowflake, params *BanMemberParams, flags ...Flag) (err error)

BanMember [REST] Create a guild ban, and optionally delete previous messages sent by the banned user. Requires the 'BAN_MEMBERS' permission. Returns a 204 empty response on success. Fires a Guild Ban Create Gateway event.

Method                  PUT
Endpoint                /Guilds/{guild.id}/bans/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#create-guild-ban
Reviewed                2018-08-18
Comment                 -

func (*Client) Cacher

func (c *Client) Cacher() Cacher

Cacher returns the cacheLink manager for the session

func (*Client) Connect

func (c *Client) Connect(ctx context.Context) (err error)

Connect establishes a websocket connection to the discord API

func (*Client) CreateChannelInvites

func (c *Client) CreateChannelInvites(ctx context.Context, channelID Snowflake, params *CreateChannelInvitesParams, flags ...Flag) (ret *Invite, err error)

CreateChannelInvites [REST] Create a new invite object for the channel. Only usable for guild Channels. Requires the CREATE_INSTANT_INVITE permission. All JSON parameters for this route are optional, however the request body is not. If you are not sending any fields, you still have to send an empty JSON object ({}). Returns an invite object.

Method                  POST
Endpoint                /Channels/{channel.id}/invites
Discord documentation   https://discordapp.com/developers/docs/resources/channel#create-channel-invite
Reviewed                2018-06-07
Comment                 -

func (*Client) CreateDM

func (c *Client) CreateDM(ctx context.Context, recipientID Snowflake, flags ...Flag) (ret *Channel, err error)

CreateDM [REST] Create a new DM channel with a user. Returns a DM channel object.

Method                  POST
Endpoint                /Users/@me/Channels
Discord documentation   https://discordapp.com/developers/docs/resources/user#create-dm
Reviewed                2019-02-23
Comment                 -

func (*Client) CreateGroupDM

func (c *Client) CreateGroupDM(ctx context.Context, params *CreateGroupDMParams, flags ...Flag) (ret *Channel, err error)

CreateGroupDM [REST] Create a new group DM channel with multiple Users. Returns a DM channel object. This endpoint was intended to be used with the now-deprecated GameBridge SDK. DMs created with this endpoint will not be shown in the Discord Client

Method                  POST
Endpoint                /Users/@me/Channels
Discord documentation   https://discordapp.com/developers/docs/resources/user#create-group-dm
Reviewed                2019-02-19
Comment                 -

func (*Client) CreateGuild

func (c *Client) CreateGuild(ctx context.Context, guildName string, params *CreateGuildParams, flags ...Flag) (ret *Guild, err error)

CreateGuild [REST] Create a new guild. Returns a guild object on success. Fires a Guild Create Gateway event.

 Method                  POST
 Endpoint                /Guilds
 Discord documentation   https://discordapp.com/developers/docs/resources/guild#create-guild
 Reviewed                2018-08-16
 Comment                 This endpoint. can be used only by bots in less than 10 Guilds. Creating channel
                         categories from this endpoint. is not supported.
							The params argument is optional.

func (*Client) CreateGuildChannel

func (c *Client) CreateGuildChannel(ctx context.Context, guildID Snowflake, channelName string, params *CreateGuildChannelParams, flags ...Flag) (ret *Channel, err error)

CreateGuildChannel [REST] Create a new channel object for the guild. Requires the 'MANAGE_CHANNELS' permission. Returns the new channel object on success. Fires a Channel Create Gateway event.

Method                  POST
Endpoint                /Guilds/{guild.id}/Channels
Discord documentation   https://discordapp.com/developers/docs/resources/guild#create-guild-channel
Reviewed                2018-08-17
Comment                 All parameters for this endpoint. are optional excluding 'name'

func (*Client) CreateGuildEmoji

func (c *Client) CreateGuildEmoji(ctx context.Context, guildID Snowflake, params *CreateGuildEmojiParams, flags ...Flag) (emoji *Emoji, err error)

CreateGuildEmoji [REST] Create a new emoji for the guild. Requires the 'MANAGE_EMOJIS' permission. Returns the new emoji object on success. Fires a Guild Emojis Update Gateway event.

Method                  POST
Endpoint                /Guilds/{guild.id}/emojis
Discord documentation   https://discordapp.com/developers/docs/resources/emoji#create-guild-emoji
Reviewed                2019-02-20
Comment                 Emojis and animated emojis have a maximum file size of 256kb. Attempting to upload
                        an emoji larger than this limit will fail and return 400 Bad Request and an
                        error message, but not a JSON status code.

func (*Client) CreateGuildIntegration

func (c *Client) CreateGuildIntegration(ctx context.Context, guildID Snowflake, params *CreateGuildIntegrationParams, flags ...Flag) (err error)

CreateGuildIntegration [REST] Attach an integration object from the current user to the guild. Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success. Fires a Guild Integrations Update Gateway event.

Method                  POST
Endpoint                /Guilds/{guild.id}/integrations
Discord documentation   https://discordapp.com/developers/docs/resources/guild#create-guild-integration
Reviewed                2018-08-18
Comment                 -

func (*Client) CreateGuildRole

func (c *Client) CreateGuildRole(ctx context.Context, id Snowflake, params *CreateGuildRoleParams, flags ...Flag) (ret *Role, err error)

CreateGuildRole [REST] Create a new role for the guild. Requires the 'MANAGE_ROLES' permission. Returns the new role object on success. Fires a Guild Role Create Gateway event.

Method                  POST
Endpoint                /Guilds/{guild.id}/roles
Discord documentation   https://discordapp.com/developers/docs/resources/guild#create-guild-role
Reviewed                2018-08-18
Comment                 All JSON params are optional.

func (*Client) CreateMessage

func (c *Client) CreateMessage(ctx context.Context, channelID Snowflake, params *CreateMessageParams, flags ...Flag) (ret *Message, err error)

CreateMessage [REST] Post a message to a guild text or DM channel. If operating on a guild channel, this endpoint requires the 'SEND_MESSAGES' permission to be present on the current user. If the tts field is set to true, the SEND_TTS_MESSAGES permission is required for the message to be spoken. Returns a message object. Fires a Message Create Gateway event. See message formatting for more information on how to properly format messages. The maximum request size when sending a message is 8MB.

Method                  POST
Endpoint                /Channels/{channel.id}/messages
Discord documentation   https://discordapp.com/developers/docs/resources/channel#create-message
Reviewed                2018-06-10
Comment                 Before using this endpoint, you must connect to and identify with a gateway at least once.

func (*Client) CreateReaction

func (c *Client) CreateReaction(ctx context.Context, channelID, messageID Snowflake, emoji interface{}, flags ...Flag) (err error)

CreateReaction [REST] Create a reaction for the message. This endpoint requires the 'READ_MESSAGE_HISTORY' permission to be present on the current user. Additionally, if nobody else has reacted to the message using this emoji, this endpoint requires the 'ADD_REACTIONS' permission to be present on the current user. Returns a 204 empty response on success. The maximum request size when sending a message is 8MB.

Method                  PUT
Endpoint                /Channels/{channel.id}/messages/{message.id}/reactions/{emoji}/@me
Discord documentation   https://discordapp.com/developers/docs/resources/channel#create-reaction
Reviewed                2019-01-30
Comment                 emoji either unicode (string) or *Emoji with an snowflake Snowflake if it's custom

func (*Client) CreateWebhook

func (c *Client) CreateWebhook(ctx context.Context, channelID Snowflake, params *CreateWebhookParams, flags ...Flag) (ret *Webhook, err error)

CreateWebhook [REST] Create a new webhook. Requires the 'MANAGE_WEBHOOKS' permission. Returns a webhook object on success.

Method                  POST
Endpoint                /Channels/{channel.id}/webhooks
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#create-webhook
Reviewed                2018-08-14
Comment                 -

func (*Client) DeleteAllReactions

func (c *Client) DeleteAllReactions(ctx context.Context, channelID, messageID Snowflake, flags ...Flag) (err error)

DeleteAllReactions [REST] Deletes all reactions on a message. This endpoint requires the 'MANAGE_MESSAGES' permission to be present on the current user.

Method                  DELETE
Endpoint                /Channels/{channel.id}/messages/{message.id}/reactions
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-all-reactions
Reviewed                2019-01-28
Comment                 emoji either unicode (string) or *Emoji with an snowflake Snowflake if it's custom

func (*Client) DeleteChannel

func (c *Client) DeleteChannel(ctx context.Context, channelID Snowflake, flags ...Flag) (channel *Channel, err error)

DeleteChannel [REST] Delete a channel, or close a private message. Requires the 'MANAGE_CHANNELS' permission for the guild. Deleting a category does not delete its child Channels; they will have their parent_id removed and a Channel Update Gateway event will fire for each of them. Returns a channel object on success. Fires a Channel Delete Gateway event.

Method                  Delete
Endpoint                /Channels/{channel.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#deleteclose-channel
Reviewed                2018-10-09
Comment                 Deleting a guild channel cannot be undone. Use this with caution, as it
                        is impossible to undo this action when performed on a guild channel. In
                        contrast, when used with a private message, it is possible to undo the
                        action by opening a private message with the recipient again.

func (*Client) DeleteChannelPermission

func (c *Client) DeleteChannelPermission(ctx context.Context, channelID, overwriteID Snowflake, flags ...Flag) (err error)

DeleteChannelPermission [REST] Delete a channel permission overwrite for a user or role in a channel. Only usable for guild Channels. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success. For more information about permissions, see permissions: https://discordapp.com/developers/docs/topics/permissions#permissions

Method                  DELETE
Endpoint                /Channels/{channel.id}/permissions/{overwrite.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-channel-permission
Reviewed                2018-06-07
Comment                 -

func (*Client) DeleteFromDiscord

func (c *Client) DeleteFromDiscord(ctx context.Context, obj discordDeleter, flags ...Flag) (err error)

DeleteFromDiscord if the given object has implemented the private interface discordDeleter this method can be used to delete said object.

func (*Client) DeleteGuild

func (c *Client) DeleteGuild(ctx context.Context, id Snowflake, flags ...Flag) (err error)

DeleteGuild [REST] Delete a guild permanently. User must be owner. Returns 204 No Content on success. Fires a Guild Delete Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#delete-guild
Reviewed                2018-08-17
Comment                 -

func (*Client) DeleteGuildEmoji

func (c *Client) DeleteGuildEmoji(ctx context.Context, guildID, emojiID Snowflake, flags ...Flag) (err error)

DeleteGuildEmoji [REST] Delete the given emoji. Requires the 'MANAGE_EMOJIS' permission. Returns 204 No Content on success. Fires a Guild Emojis Update Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}/emojis/{emoji.id}
Discord documentation   https://discordapp.com/developers/docs/resources/emoji#delete-guild-emoji
Reviewed                2018-06-10
Comment                 -

func (*Client) DeleteGuildIntegration

func (c *Client) DeleteGuildIntegration(ctx context.Context, guildID, integrationID Snowflake, flags ...Flag) (err error)

DeleteGuildIntegration [REST] Delete the attached integration object for the guild. Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success. Fires a Guild Integrations Update Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}/integrations/{integration.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#delete-guild-integration
Reviewed                2018-08-18
Comment                 -

func (*Client) DeleteGuildRole

func (c *Client) DeleteGuildRole(ctx context.Context, guildID, roleID Snowflake, flags ...Flag) (err error)

DeleteGuildRole [REST] Delete a guild role. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success. Fires a Guild Role Delete Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}/roles/{role.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#delete-guild-role
Reviewed                2018-08-18
Comment                 -

func (*Client) DeleteInvite

func (c *Client) DeleteInvite(ctx context.Context, inviteCode string, flags ...Flag) (deleted *Invite, err error)

DeleteInvite [REST] Delete an invite. Requires the MANAGE_CHANNELS permission. Returns an invite object on success.

Method                  DELETE
Endpoint                /invites/{invite.code}
Discord documentation   https://discordapp.com/developers/docs/resources/invite#delete-invite
Reviewed                2018-06-10
Comment                 -

func (*Client) DeleteMessage

func (c *Client) DeleteMessage(ctx context.Context, channelID, msgID Snowflake, flags ...Flag) (err error)

DeleteMessage [REST] Delete a message. If operating on a guild channel and trying to delete a message that was not sent by the current user, this endpoint requires the 'MANAGE_MESSAGES' permission. Returns a 204 empty response on success. Fires a Message Delete Gateway event.

Method                  DELETE
Endpoint                /Channels/{channel.id}/messages/{message.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-message
Reviewed                2018-06-10
Comment                 -

func (*Client) DeleteMessages

func (c *Client) DeleteMessages(ctx context.Context, chanID Snowflake, params *DeleteMessagesParams, flags ...Flag) (err error)

DeleteMessages [REST] Delete multiple messages in a single request. This endpoint can only be used on guild Channels and requires the 'MANAGE_MESSAGES' permission. Returns a 204 empty response on success. Fires multiple Message Delete Gateway events.Any message IDs given that do not exist or are invalid will count towards the minimum and maximum message count (currently 2 and 100 respectively). Additionally, duplicated IDs will only be counted once.

Method                  POST
Endpoint                /Channels/{channel.id}/messages/bulk-delete
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-message
Reviewed                2018-06-10
Comment                 This endpoint will not delete messages older than 2 weeks, and will fail if any message
                        provided is older than that.

func (*Client) DeleteOwnReaction

func (c *Client) DeleteOwnReaction(ctx context.Context, channelID, messageID Snowflake, emoji interface{}, flags ...Flag) (err error)

DeleteOwnReaction [REST] Delete a reaction the current user has made for the message. Returns a 204 empty response on success.

Method                  DELETE
Endpoint                /Channels/{channel.id}/messages/{message.id}/reactions/{emoji}/@me
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-own-reaction
Reviewed                2019-01-28
Comment                 emoji either unicode (string) or *Emoji with an snowflake Snowflake if it's custom

func (*Client) DeleteUserReaction

func (c *Client) DeleteUserReaction(ctx context.Context, channelID, messageID, userID Snowflake, emoji interface{}, flags ...Flag) (err error)

DeleteUserReaction [REST] Deletes another user's reaction. This endpoint requires the 'MANAGE_MESSAGES' permission to be present on the current user. Returns a 204 empty response on success.

Method                  DELETE
Endpoint                /Channels/{channel.id}/messages/{message.id}/reactions/{emoji}/@me
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-user-reaction
Reviewed                2019-01-28
Comment                 emoji either unicode (string) or *Emoji with an snowflake Snowflake if it's custom

func (*Client) DeleteWebhook

func (c *Client) DeleteWebhook(ctx context.Context, id Snowflake, flags ...Flag) (err error)

DeleteWebhook [REST] Delete a webhook permanently. User must be owner. Returns a 204 NO CONTENT response on success.

Method                  DELETE
Endpoint                /webhooks/{webhook.id}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#delete-webhook
Reviewed                2018-08-14
Comment                 -

func (*Client) DeleteWebhookWithToken

func (c *Client) DeleteWebhookWithToken(ctx context.Context, id Snowflake, token string, flags ...Flag) (err error)

DeleteWebhookWithToken [REST] Same as DeleteWebhook, except this call does not require authentication.

Method                  DELETE
Endpoint                /webhooks/{webhook.id}/{webhook.token}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#delete-webhook-with-token
Reviewed                2018-08-14
Comment                 -

func (*Client) Disconnect

func (c *Client) Disconnect() (err error)

Disconnect closes the discord websocket connection

func (*Client) DisconnectOnInterrupt

func (c *Client) DisconnectOnInterrupt() (err error)

DisconnectOnInterrupt wait until a termination signal is detected

func (*Client) Emit

func (c *Client) Emit(name gatewayCmdName, payload gatewayCmdPayload) (unchandledGuildIDs []Snowflake, err error)

Emit sends a socket command directly to Discord.

func (*Client) EstimatePruneMembersCount

func (c *Client) EstimatePruneMembersCount(ctx context.Context, id Snowflake, days int, flags ...Flag) (estimate int, err error)

EstimatePruneMembersCount [REST] Returns an object with one 'pruned' key indicating the number of members that would be removed in a prune operation. Requires the 'KICK_MEMBERS' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/prune
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-prune-count
Reviewed                2018-08-18
Comment                 -

func (*Client) ExecuteGitHubWebhook

func (c *Client) ExecuteGitHubWebhook(ctx context.Context, params *ExecuteWebhookParams, wait bool, flags ...Flag) (err error)

ExecuteGitHubWebhook [REST] Trigger a webhook in Discord from the GitHub app.

Method                  POST
Endpoint                /webhooks/{webhook.id}/{webhook.token}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#execute-githubcompatible-webhook
Reviewed                2018-08-14
Comment                 Add a new webhook to your GitHub repo (in the repo's settings), and use this endpoint.
                        as the "Payload URL." You can choose what events your Discord channel receives by
                        choosing the "Let me select individual events" option and selecting individual
                        events for the new webhook you're configuring.

func (*Client) ExecuteSlackWebhook

func (c *Client) ExecuteSlackWebhook(ctx context.Context, params *ExecuteWebhookParams, wait bool, flags ...Flag) (err error)

ExecuteSlackWebhook [REST] Trigger a webhook in Discord from the Slack app.

Method                  POST
Endpoint                /webhooks/{webhook.id}/{webhook.token}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#execute-slackcompatible-webhook
Reviewed                2018-08-14
Comment                 Refer to Slack's documentation for more information. We do not support Slack's channel,
                        icon_emoji, mrkdwn, or mrkdwn_in properties.

func (*Client) ExecuteWebhook

func (c *Client) ExecuteWebhook(ctx context.Context, params *ExecuteWebhookParams, wait bool, URLSuffix string, flags ...Flag) (err error)

ExecuteWebhook [REST] Trigger a webhook in Discord.

Method                  POST
Endpoint                /webhooks/{webhook.id}/{webhook.token}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#execute-webhook
Reviewed                2018-08-14
Comment                 This endpoint. supports both JSON and form data bodies. It does require
                        multipart/form-data requests instead of the normal JSON request type when
                        uploading files. Make sure you set your Content-Type to multipart/form-data if
                        you're doing that. Note that in that case, the embeds field cannot be used, but
                        you can pass an url-encoded JSON body as a form value for payload_json.
Comment#2               For the webhook embed objects, you can set every field except type (it will be
                        rich regardless of if you try to set it), provider, video, and any height, width,
                        or proxy_url values for images.

func (*Client) GetChannel

func (c *Client) GetChannel(ctx context.Context, channelID Snowflake, flags ...Flag) (ret *Channel, err error)

GetChannel [REST] Get a channel by Snowflake. Returns a channel object.

Method                  GET
Endpoint                /Channels/{channel.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#get-channel
Reviewed                2018-06-07
Comment                 -

func (*Client) GetChannelInvites

func (c *Client) GetChannelInvites(ctx context.Context, channelID Snowflake, flags ...Flag) (invites []*Invite, err error)

GetChannelInvites [REST] Returns a list of invite objects (with invite metadata) for the channel. Only usable for guild Channels. Requires the 'MANAGE_CHANNELS' permission.

Method                  GET
Endpoint                /Channels/{channel.id}/invites
Discord documentation   https://discordapp.com/developers/docs/resources/channel#get-channel-invites
Reviewed                2018-06-07
Comment                 -

func (*Client) GetChannelWebhooks

func (c *Client) GetChannelWebhooks(ctx context.Context, channelID Snowflake, flags ...Flag) (ret []*Webhook, err error)

GetChannelWebhooks [REST] Returns a list of channel webhook objects. Requires the 'MANAGE_WEBHOOKS' permission.

Method                  POST
Endpoint                /Channels/{channel.id}/webhooks
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#get-channel-webhooks
Reviewed                2018-08-14
Comment                 -

func (*Client) GetConnectedGuilds

func (c *Client) GetConnectedGuilds() []Snowflake

GetConnectedGuilds get a list over guild IDs that this Client is "connected to"; or have joined through the ws connection. This will always hold the different Guild IDs, while the GetGuilds or GetCurrentUserGuilds might be affected by Cache configuration.

func (*Client) GetCurrentUser

func (c *Client) GetCurrentUser(ctx context.Context, flags ...Flag) (user *User, err error)

GetCurrentUser [REST] Returns the user object of the requester's account. For OAuth2, this requires the identify scope, which will return the object without an email, and optionally the email scope, which returns the object with an email.

Method                  GET
Endpoint                /Users/@me
Discord documentation   https://discordapp.com/developers/docs/resources/user#get-current-user
Reviewed                2019-02-23
Comment                 -

func (*Client) GetCurrentUserGuilds

func (c *Client) GetCurrentUserGuilds(ctx context.Context, params *GetCurrentUserGuildsParams, flags ...Flag) (ret []*PartialGuild, err error)

GetCurrentUserGuilds [REST] Returns a list of partial guild objects the current user is a member of. Requires the Guilds OAuth2 scope.

Method                  GET
Endpoint                /Users/@me/Guilds
Discord documentation   https://discordapp.com/developers/docs/resources/user#get-current-user-guilds
Reviewed                2019-02-18
Comment                 This endpoint. returns 100 Guilds by default, which is the maximum number of
                        Guilds a non-bot user can join. Therefore, pagination is not needed for
                        integrations that need to get a list of Users' Guilds.

func (*Client) GetGateway

func (c *Client) GetGateway(ctx context.Context) (gateway *gateway.Gateway, err error)

GetGateway [REST] Returns an object with a single valid WSS URL, which the Client can use for Connecting. Clients should cacheLink this value and only call this endpoint to retrieve a new URL if they are unable to properly establish a connection using the cached version of the URL.

Method                  GET
Endpoint                /gateway
Discord documentation   https://discordapp.com/developers/docs/topics/gateway#get-gateway
Reviewed                2018-10-12
Comment                 This endpoint does not require authentication.

func (*Client) GetGatewayBot

func (c *Client) GetGatewayBot(ctx context.Context) (gateway *gateway.GatewayBot, err error)

GetGatewayBot [REST] Returns an object based on the information in Get Gateway, plus additional metadata that can help during the operation of large or sharded bots. Unlike the Get Gateway, this route should not be cached for extended periods of time as the value is not guaranteed to be the same per-call, and changes as the bot joins/leaves Guilds.

Method                  GET
Endpoint                /gateway/bot
Discord documentation   https://discordapp.com/developers/docs/topics/gateway#get-gateway-bot
Reviewed                2018-10-12
Comment                 This endpoint requires authentication using a valid bot token.

func (*Client) GetGuild

func (c *Client) GetGuild(ctx context.Context, id Snowflake, flags ...Flag) (guild *Guild, err error)

GetGuild [REST] Returns the guild object for the given id.

Method                  GET
Endpoint                /Guilds/{guild.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild
Reviewed                2018-08-17
Comment                 -

func (*Client) GetGuildAuditLogs

func (c *Client) GetGuildAuditLogs(ctx context.Context, guildID Snowflake, flags ...Flag) (builder *guildAuditLogsBuilder)

GetGuildAuditLogs [REST] Returns an audit log object for the guild. Requires the 'VIEW_AUDIT_LOG' permission. Note that this request will _always_ send a REST request, regardless of you calling IgnoreCache or not.

Method                   GET
Endpoint                 /Guilds/{guild.id}/audit-logs
Discord documentation    https://discordapp.com/developers/docs/resources/audit-log#get-guild-audit-log
Reviewed                 2018-06-05
Comment                  -
Note                     Check the last entry in the cacheLink, to avoid fetching data we already got

func (*Client) GetGuildBan

func (c *Client) GetGuildBan(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (ret *Ban, err error)

GetGuildBan [REST] Returns a ban object for the given user or a 404 not found if the ban cannot be found. Requires the 'BAN_MEMBERS' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/bans/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-ban
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildBans

func (c *Client) GetGuildBans(ctx context.Context, id Snowflake, flags ...Flag) (bans []*Ban, err error)

GetGuildBans [REST] Returns a list of ban objects for the Users banned from this guild. Requires the 'BAN_MEMBERS' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/bans
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-bans
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildChannels

func (c *Client) GetGuildChannels(ctx context.Context, guildID Snowflake, flags ...Flag) (ret []*Channel, err error)

GetGuildChannels [REST] Returns a list of guild channel objects.

Method                  GET
Endpoint                /Guilds/{guild.id}/Channels
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-channels
Reviewed                2018-08-17
Comment                 -

func (*Client) GetGuildEmbed

func (c *Client) GetGuildEmbed(ctx context.Context, guildID Snowflake, flags ...Flag) (embed *GuildEmbed, err error)

GetGuildEmbed [REST] Returns the guild embed object. Requires the 'MANAGE_GUILD' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/embed
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-embed
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildEmoji

func (c *Client) GetGuildEmoji(ctx context.Context, guildID, emojiID Snowflake, flags ...Flag) (*Emoji, error)

GetGuildEmoji [REST] Returns an emoji object for the given guild and emoji IDs.

Method                  GET
Endpoint                /Guilds/{guild.id}/emojis/{emoji.id}
Discord documentation   https://discordapp.com/developers/docs/resources/emoji#get-guild-emoji
Reviewed                2019-02-20
Comment                 -

func (*Client) GetGuildEmojis

func (c *Client) GetGuildEmojis(ctx context.Context, guildID Snowflake, flags ...Flag) (emojis []*Emoji, err error)

GetGuildEmojis [REST] Returns a list of emoji objects for the given guild.

Method                  GET
Endpoint                /Guilds/{guild.id}/emojis
Discord documentation   https://discordapp.com/developers/docs/resources/emoji#list-guild-emojis
Reviewed                2018-06-10
Comment                 -

func (*Client) GetGuildIntegrations

func (c *Client) GetGuildIntegrations(ctx context.Context, id Snowflake, flags ...Flag) (ret []*Integration, err error)

GetGuildIntegrations [REST] Returns a list of integration objects for the guild. Requires the 'MANAGE_GUILD' permission.

Method                   GET
Endpoint                 /Guilds/{guild.id}/integrations
Discord documentation    https://discordapp.com/developers/docs/resources/guild#get-guild-integrations
Reviewed                 2018-08-18
Comment                  -

func (*Client) GetGuildInvites

func (c *Client) GetGuildInvites(ctx context.Context, id Snowflake, flags ...Flag) (ret []*Invite, err error)

GetGuildInvites [REST] Returns a list of invite objects (with invite metadata) for the guild. Requires the 'MANAGE_GUILD' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/invites
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-invites
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildRoles

func (c *Client) GetGuildRoles(ctx context.Context, guildID Snowflake, flags ...Flag) (ret []*Role, err error)

GetGuildRoles [REST] Returns a list of role objects for the guild.

Method                  GET
Endpoint                /Guilds/{guild.id}/roles
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-roles
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildVanityURL

func (c *Client) GetGuildVanityURL(ctx context.Context, guildID Snowflake, flags ...Flag) (ret *PartialInvite, err error)

GetGuildVanityURL [REST] Returns a partial invite object for Guilds with that feature enabled. Requires the 'MANAGE_GUILD' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/vanity-url
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-vanity-url
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildVoiceRegions

func (c *Client) GetGuildVoiceRegions(ctx context.Context, id Snowflake, flags ...Flag) (ret []*VoiceRegion, err error)

GetGuildVoiceRegions [REST] Returns a list of voice region objects for the guild. Unlike the similar /voice route, this returns VIP servers when the guild is VIP-enabled.

Method                  GET
Endpoint                /Guilds/{guild.id}/regions
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-voice-regions
Reviewed                2018-08-18
Comment                 -

func (*Client) GetGuildWebhooks

func (c *Client) GetGuildWebhooks(ctx context.Context, guildID Snowflake, flags ...Flag) (ret []*Webhook, err error)

GetGuildWebhooks [REST] Returns a list of guild webhook objects. Requires the 'MANAGE_WEBHOOKS' permission.

Method                  GET
Endpoint                /Guilds/{guild.id}/webhooks
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#get-guild-webhooks
Reviewed                2018-08-14
Comment                 -

func (*Client) GetGuilds

func (c *Client) GetGuilds(ctx context.Context, params *GetCurrentUserGuildsParams, flags ...Flag) ([]*Guild, error)

func (*Client) GetInvite

func (c *Client) GetInvite(ctx context.Context, inviteCode string, params URLQueryStringer, flags ...Flag) (invite *Invite, err error)

GetInvite [REST] Returns an invite object for the given code.

Method                  GET
Endpoint                /invites/{invite.code}
Discord documentation   https://discordapp.com/developers/docs/resources/invite#get-invite
Reviewed                2018-06-10
Comment                 -
withMemberCount: whether or not the invite should contain the approximate number of members

func (*Client) GetMember

func (c *Client) GetMember(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (ret *Member, err error)

GetMember [REST] Returns a guild member object for the specified user.

Method                  GET
Endpoint                /Guilds/{guild.id}/members/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#get-guild-member
Reviewed                2018-08-17
Comment                 -

func (*Client) GetMemberPermissions

func (c *Client) GetMemberPermissions(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (permissions PermissionBits, err error)

GetMemberPermissions populates a uint64 with all the permission flags

func (*Client) GetMembers

func (c *Client) GetMembers(ctx context.Context, guildID Snowflake, params *GetMembersParams, flags ...Flag) (members []*Member, err error)

GetMembers uses the GetGuildMembers endpoint iteratively until the your restriction/query params are met.

func (*Client) GetMessage

func (c *Client) GetMessage(ctx context.Context, channelID, messageID Snowflake, flags ...Flag) (message *Message, err error)

GetMessage [REST] Returns a specific message in the channel. If operating on a guild channel, this endpoints requires the 'READ_MESSAGE_HISTORY' permission to be present on the current user. Returns a message object on success.

Method                  GET
Endpoint                /Channels/{channel.id}/messages/{message.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#get-channel-message
Reviewed                2018-06-10
Comment                 -

func (*Client) GetMessages

func (c *Client) GetMessages(ctx context.Context, channelID Snowflake, filter *GetMessagesParams, flags ...Flag) (messages []*Message, err error)

GetMessages bypasses discord limitations and iteratively fetches messages until the set filters are met.

func (*Client) GetPermissions

func (c *Client) GetPermissions() (permissions PermissionBits)

GetPermissions returns the minimum bot requirements.

func (*Client) GetPinnedMessages

func (c *Client) GetPinnedMessages(ctx context.Context, channelID Snowflake, flags ...Flag) (ret []*Message, err error)

GetPinnedMessages [REST] Returns all pinned messages in the channel as an array of message objects.

Method                  GET
Endpoint                /Channels/{channel.id}/pins
Discord documentation   https://discordapp.com/developers/docs/resources/channel#get-pinned-messages
Reviewed                2018-06-10
Comment                 -

func (*Client) GetReaction

func (c *Client) GetReaction(ctx context.Context, channelID, messageID Snowflake, emoji interface{}, params URLQueryStringer, flags ...Flag) (ret []*User, err error)

GetReaction [REST] Get a list of Users that reacted with this emoji. Returns an array of user objects on success.

Method                  GET
Endpoint                /Channels/{channel.id}/messages/{message.id}/reactions/{emoji}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#get-reactions
Reviewed                2019-01-28
Comment                 emoji either unicode (string) or *Emoji with an snowflake Snowflake if it's custom

func (*Client) GetUser

func (c *Client) GetUser(ctx context.Context, id Snowflake, flags ...Flag) (*User, error)

GetUser [REST] Returns a user object for a given user Snowflake.

Method                  GET
Endpoint                /Users/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/user#get-user
Reviewed                2018-06-10
Comment                 -

func (*Client) GetUserConnections

func (c *Client) GetUserConnections(ctx context.Context, flags ...Flag) (connections []*UserConnection, err error)

GetUserConnections [REST] Returns a list of connection objects. Requires the connections OAuth2 scope.

Method                  GET
Endpoint                /Users/@me/connections
Discord documentation   https://discordapp.com/developers/docs/resources/user#get-user-connections
Reviewed                2019-02-19
Comment                 -

func (*Client) GetUserDMs deprecated

This method has been deprecated.
func (c *Client) GetUserDMs(ctx context.Context, flags ...Flag) (ret []*Channel, err error)

GetUserDMs [REST] Returns a list of DM channel objects.

 Method                  GET
 Endpoint                /Users/@me/Channels
 Discord documentation   https://discordapp.com/developers/docs/resources/user#get-user-dms
 Reviewed                2019-02-19
 Comment                 Apparently Discord removed support for this in 2016 and updated their docs 2 years after..
							https://github.com/discordapp/discord-api-docs/issues/184
							For now I'll just leave this here, until I can do a Cache lookup. Making this Cache
							dependent.

Deprecated: Needs Cache checking to get the actual list of Channels

func (*Client) GetVoiceRegions

func (c *Client) GetVoiceRegions(ctx context.Context, flags ...Flag) (regions []*VoiceRegion, err error)

GetVoiceRegionsBuilder [REST] Returns an array of voice region objects that can be used when creating servers.

Method                  GET
Endpoint                /voice/regions
Discord documentation   https://discordapp.com/developers/docs/resources/voice#list-voice-regions
Reviewed                2018-08-21
Comment                 -

func (*Client) GetWebhook

func (c *Client) GetWebhook(ctx context.Context, id Snowflake, flags ...Flag) (ret *Webhook, err error)

GetWebhook [REST] Returns the new webhook object for the given id.

Method                  GET
Endpoint                /webhooks/{webhook.id}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#get-webhook
Reviewed                2018-08-14
Comment                 -

func (*Client) GetWebhookWithToken

func (c *Client) GetWebhookWithToken(ctx context.Context, id Snowflake, token string, flags ...Flag) (ret *Webhook, err error)

GetWebhookWithToken [REST] Same as GetWebhook, except this call does not require authentication and returns no user in the webhook object.

Method                  GET
Endpoint                /webhooks/{webhook.id}/{webhook.token}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#get-webhook-with-token
Reviewed                2018-08-14
Comment                 -

func (*Client) GuildsReady

func (c *Client) GuildsReady(cb func())

GuildsReady is triggered once all unavailable Guilds given in the READY event has loaded from their respective GUILD_CREATE events.

func (*Client) HeartbeatLatencies

func (c *Client) HeartbeatLatencies() (latencies map[uint]time.Duration, err error)

HeartbeatLatencies returns latencies mapped to each shard, by their respective ID. shardID => latency.

func (*Client) InviteURL

func (c *Client) InviteURL(ctx context.Context) (u string, err error)

InviteURL creates a URL that can be used to invite this bot to a guild/server. Note that it depends on the bot ID to be after the Discord update where the Client ID is the same as the Bot ID.

By default the permissions will be 0, as in none. If you want to add/set the minimum required permissions for your bot to run successfully, you should utilise

Client.

func (*Client) KickMember

func (c *Client) KickMember(ctx context.Context, guildID, userID Snowflake, reason string, flags ...Flag) (err error)

RemoveGuildMember [REST] Remove a member from a guild. Requires 'KICK_MEMBERS' permission. Returns a 204 empty response on success. Fires a Guild Member Remove Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}/members/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#remove-guild-member
Reviewed                2018-08-18
Comment                 -

func (*Client) KickParticipant

func (c *Client) KickParticipant(ctx context.Context, channelID, userID Snowflake, flags ...Flag) (err error)

KickParticipant [REST] Removes a recipient from a Group DM. Returns a 204 empty response on success.

Method                  DELETE
Endpoint                /Channels/{channel.id}/recipients/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#group-dm-remove-recipient
Reviewed                2018-06-10
Comment                 -

func (*Client) KickVoiceParticipant

func (c *Client) KickVoiceParticipant(ctx context.Context, guildID, userID Snowflake) error

func (*Client) LeaveGuild

func (c *Client) LeaveGuild(ctx context.Context, id Snowflake, flags ...Flag) (err error)

LeaveGuild [REST] Leave a guild. Returns a 204 empty response on success.

Method                  DELETE
Endpoint                /Users/@me/Guilds/{guild.id}
Discord documentation   https://discordapp.com/developers/docs/resources/user#leave-guild
Reviewed                2019-02-18
Comment                 -

func (*Client) Logger

func (c *Client) Logger() logger.Logger

Logger returns the log instance of Disgord. Note that this instance is never nil. When the conf.Logger is not assigned an empty struct is used instead. Such that all calls are simply discarded at compile time removing the need for nil checks.

func (*Client) Myself deprecated

This method has been deprecated.
func (c *Client) Myself(ctx context.Context) (user *User, err error)

Myself get the current user / connected user Deprecated: use GetCurrentUser instead

func (*Client) On

func (c *Client) On(event string, inputs ...interface{})

On creates a specification to be executed on the given event. The specification consists of, in order, 0 or more middlewares, 1 or more handlers, 0 or 1 controller. On incorrect ordering, or types, the method will panic. See reactor.go for types.

Each of the three sub-types of a specification is run in sequence, as well as the specifications registered for a event. However, the slice of specifications are executed in a goroutine to avoid blocking future events. The middlewares allows manipulating the event data before it reaches the handlers. The handlers executes short-running logic based on the event data (use go routine if you need a long running task). The controller dictates lifetime of the specification.

// a handler that is executed on every Ready event
Client.On(EvtReady, onReady)

// a handler that runs only the first three times a READY event is fired
Client.On(EvtReady, onReady, &Ctrl{Runs: 3})

// a handler that only runs for events within the first 10 minutes
Client.On(EvtReady, onReady, &Ctrl{Duration: 10*time.Minute})

Another example is to create a voting system where you specify a deadline instead of a Runs counter:

On("MESSAGE_CREATE", mdlwHasMentions, handleMsgsWithMentions, saveVoteToDB, &Ctrl{Until:time.Now().Add(time.Hour)})

You can use your own Ctrl struct, as long as it implements disgord.HandlerCtrl. Do not execute long running tasks in the methods. Use a go routine instead.

If the HandlerCtrl.OnInsert returns an error, the related handlers are still added to the dispatcher. But the error is logged to the injected logger instance (log.Error).

This ctrl feature was inspired by https://github.com/discordjs/discord.js

func (*Client) OnChannelCreate

func (c *Client) OnChannelCreate(mdlws []Middleware, handlers []HandlerChannelCreate, ctrl ...HandlerCtrl)

func (*Client) OnChannelDelete

func (c *Client) OnChannelDelete(mdlws []Middleware, handlers []HandlerChannelDelete, ctrl ...HandlerCtrl)

func (*Client) OnChannelPinsUpdate

func (c *Client) OnChannelPinsUpdate(mdlws []Middleware, handlers []HandlerChannelPinsUpdate, ctrl ...HandlerCtrl)

func (*Client) OnChannelUpdate

func (c *Client) OnChannelUpdate(mdlws []Middleware, handlers []HandlerChannelUpdate, ctrl ...HandlerCtrl)

func (*Client) OnGuildBanAdd

func (c *Client) OnGuildBanAdd(mdlws []Middleware, handlers []HandlerGuildBanAdd, ctrl ...HandlerCtrl)

func (*Client) OnGuildBanRemove

func (c *Client) OnGuildBanRemove(mdlws []Middleware, handlers []HandlerGuildBanRemove, ctrl ...HandlerCtrl)

func (*Client) OnGuildCreate

func (c *Client) OnGuildCreate(mdlws []Middleware, handlers []HandlerGuildCreate, ctrl ...HandlerCtrl)

func (*Client) OnGuildDelete

func (c *Client) OnGuildDelete(mdlws []Middleware, handlers []HandlerGuildDelete, ctrl ...HandlerCtrl)

func (*Client) OnGuildEmojisUpdate

func (c *Client) OnGuildEmojisUpdate(mdlws []Middleware, handlers []HandlerGuildEmojisUpdate, ctrl ...HandlerCtrl)

func (*Client) OnGuildIntegrationsUpdate

func (c *Client) OnGuildIntegrationsUpdate(mdlws []Middleware, handlers []HandlerGuildIntegrationsUpdate, ctrl ...HandlerCtrl)

func (*Client) OnGuildMemberAdd

func (c *Client) OnGuildMemberAdd(mdlws []Middleware, handlers []HandlerGuildMemberAdd, ctrl ...HandlerCtrl)

func (*Client) OnGuildMemberRemove

func (c *Client) OnGuildMemberRemove(mdlws []Middleware, handlers []HandlerGuildMemberRemove, ctrl ...HandlerCtrl)

func (*Client) OnGuildMemberUpdate

func (c *Client) OnGuildMemberUpdate(mdlws []Middleware, handlers []HandlerGuildMemberUpdate, ctrl ...HandlerCtrl)

func (*Client) OnGuildMembersChunk

func (c *Client) OnGuildMembersChunk(mdlws []Middleware, handlers []HandlerGuildMembersChunk, ctrl ...HandlerCtrl)

func (*Client) OnGuildRoleCreate

func (c *Client) OnGuildRoleCreate(mdlws []Middleware, handlers []HandlerGuildRoleCreate, ctrl ...HandlerCtrl)

func (*Client) OnGuildRoleDelete

func (c *Client) OnGuildRoleDelete(mdlws []Middleware, handlers []HandlerGuildRoleDelete, ctrl ...HandlerCtrl)

func (*Client) OnGuildRoleUpdate

func (c *Client) OnGuildRoleUpdate(mdlws []Middleware, handlers []HandlerGuildRoleUpdate, ctrl ...HandlerCtrl)

func (*Client) OnGuildUpdate

func (c *Client) OnGuildUpdate(mdlws []Middleware, handlers []HandlerGuildUpdate, ctrl ...HandlerCtrl)

func (*Client) OnMessageCreate

func (c *Client) OnMessageCreate(mdlws []Middleware, handlers []HandlerMessageCreate, ctrl ...HandlerCtrl)

func (*Client) OnMessageDelete

func (c *Client) OnMessageDelete(mdlws []Middleware, handlers []HandlerMessageDelete, ctrl ...HandlerCtrl)

func (*Client) OnMessageDeleteBulk

func (c *Client) OnMessageDeleteBulk(mdlws []Middleware, handlers []HandlerMessageDeleteBulk, ctrl ...HandlerCtrl)

func (*Client) OnMessageReactionAdd

func (c *Client) OnMessageReactionAdd(mdlws []Middleware, handlers []HandlerMessageReactionAdd, ctrl ...HandlerCtrl)

func (*Client) OnMessageReactionRemove

func (c *Client) OnMessageReactionRemove(mdlws []Middleware, handlers []HandlerMessageReactionRemove, ctrl ...HandlerCtrl)

func (*Client) OnMessageReactionRemoveAll

func (c *Client) OnMessageReactionRemoveAll(mdlws []Middleware, handlers []HandlerMessageReactionRemoveAll, ctrl ...HandlerCtrl)

func (*Client) OnMessageUpdate

func (c *Client) OnMessageUpdate(mdlws []Middleware, handlers []HandlerMessageUpdate, ctrl ...HandlerCtrl)

func (*Client) OnPresenceUpdate

func (c *Client) OnPresenceUpdate(mdlws []Middleware, handlers []HandlerPresenceUpdate, ctrl ...HandlerCtrl)

func (*Client) OnReady

func (c *Client) OnReady(mdlws []Middleware, handlers []HandlerReady, ctrl ...HandlerCtrl)

func (*Client) OnResumed

func (c *Client) OnResumed(mdlws []Middleware, handlers []HandlerResumed, ctrl ...HandlerCtrl)

func (*Client) OnTypingStart

func (c *Client) OnTypingStart(mdlws []Middleware, handlers []HandlerTypingStart, ctrl ...HandlerCtrl)

func (*Client) OnUserUpdate

func (c *Client) OnUserUpdate(mdlws []Middleware, handlers []HandlerUserUpdate, ctrl ...HandlerCtrl)

func (*Client) OnVoiceServerUpdate

func (c *Client) OnVoiceServerUpdate(mdlws []Middleware, handlers []HandlerVoiceServerUpdate, ctrl ...HandlerCtrl)

func (*Client) OnVoiceStateUpdate

func (c *Client) OnVoiceStateUpdate(mdlws []Middleware, handlers []HandlerVoiceStateUpdate, ctrl ...HandlerCtrl)

func (*Client) OnWebhooksUpdate

func (c *Client) OnWebhooksUpdate(mdlws []Middleware, handlers []HandlerWebhooksUpdate, ctrl ...HandlerCtrl)

func (*Client) PinMessage

func (c *Client) PinMessage(ctx context.Context, message *Message, flags ...Flag) error

PinMessage see Client.PinMessageID

func (*Client) PinMessageID

func (c *Client) PinMessageID(ctx context.Context, channelID, messageID Snowflake, flags ...Flag) (err error)

PinMessageID [REST] Pin a message by its ID and channel ID. Requires the 'MANAGE_MESSAGES' permission. Returns a 204 empty response on success.

Method                  PUT
Endpoint                /Channels/{channel.id}/pins/{message.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#add-pinned-channel-message
Reviewed                2018-06-10
Comment                 -

func (*Client) Pool

func (c *Client) Pool() *pools

////////////////////////////////////////////////////

METHODS

////////////////////////////////////////////////////

func (*Client) PruneMembers

func (c *Client) PruneMembers(ctx context.Context, id Snowflake, days int, reason string, flags ...Flag) (err error)

PruneMembers [REST] Kicks members from N day back. Requires the 'KICK_MEMBERS' permission. The estimate of kicked people is not returned. Use EstimatePruneMembersCount before calling PruneMembers if you need it. Fires multiple Guild Member Remove Gateway events.

Method                  POST
Endpoint                /Guilds/{guild.id}/prune
Discord documentation   https://discordapp.com/developers/docs/resources/guild#begin-guild-prune
Reviewed                2018-08-18
Comment                 -

func (*Client) RESTBucketGrouping

func (c *Client) RESTBucketGrouping() (group map[string][]string)

@Deprecated: use Client.RESTRatelimitBuckets()

func (*Client) RESTRatelimitBuckets

func (c *Client) RESTRatelimitBuckets() (group map[string][]string)

RESTBucketGrouping shows which hashed endpoints belong to which bucket hash for the REST API. Note that these bucket hashes are eventual consistent.

func (*Client) Ready

func (c *Client) Ready(cb func())

Ready triggers a given callback when all shards has gotten their first Ready event Warning: Do not call Client.Connect before this.

func (*Client) RemoveGuildMemberRole

func (c *Client) RemoveGuildMemberRole(ctx context.Context, guildID, userID, roleID Snowflake, flags ...Flag) (err error)

RemoveGuildMemberRole [REST] Removes a role from a guild member. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success. Fires a Guild Member Update Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}/members/{user.id}/roles/{role.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#remove-guild-member-role
Reviewed                2018-08-18
Comment                 -

func (*Client) Req

func (c *Client) Req() httd.Requester

Req return the request object. Used in REST requests to handle rate limits, wrong http responses, etc.

func (*Client) SendMsg

func (c *Client) SendMsg(ctx context.Context, channelID Snowflake, data ...interface{}) (msg *Message, err error)

SendMsg should convert all inputs into a single message. If you supply a object with an ID such as a channel, message, role, etc. It will become a reference. If say the Message provided does not have an ID, the Message will populate a CreateMessage with it's fields.

If you want to affect the actual message data besides .Content; provide a MessageCreateParams. The reply message will be updated by the last one provided.

func (*Client) SetCurrentUserNick

func (c *Client) SetCurrentUserNick(ctx context.Context, id Snowflake, nick string, flags ...Flag) (newNick string, err error)

SetCurrentUserNick [REST] Modifies the nickname of the current user in a guild. Returns a 200 with the nickname on success. Fires a Guild Member Update Gateway event.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/members/@me/nick
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-current-user-nick
Reviewed                2018-08-18
Comment                 -

func (*Client) SetMsgContent

func (c *Client) SetMsgContent(ctx context.Context, chanID, msgID Snowflake, content string) (*Message, error)

func (*Client) SetMsgEmbed

func (c *Client) SetMsgEmbed(ctx context.Context, chanID, msgID Snowflake, embed *Embed) (*Message, error)

func (*Client) StayConnectedUntilInterrupted

func (c *Client) StayConnectedUntilInterrupted(ctx context.Context) (err error)

StayConnectedUntilInterrupted is a simple wrapper for connect, and disconnect that listens for system interrupts. When a error happens you can terminate the application without worries.

func (*Client) String

func (c *Client) String() string

func (*Client) Suspend

func (c *Client) Suspend() (err error)

Suspend in case you want to temporary disconnect from the Gateway. But plan on connecting again without restarting your software/application, this should be used.

func (*Client) SyncGuildIntegration

func (c *Client) SyncGuildIntegration(ctx context.Context, guildID, integrationID Snowflake, flags ...Flag) (err error)

SyncGuildIntegration [REST] Sync an integration. Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success.

Method                  POST
Endpoint                /Guilds/{guild.id}/integrations/{integration.id}/sync
Discord documentation   https://discordapp.com/developers/docs/resources/guild#sync-guild-integration
Reviewed                2018-08-18
Comment                 -

func (*Client) TriggerTypingIndicator

func (c *Client) TriggerTypingIndicator(ctx context.Context, channelID Snowflake, flags ...Flag) (err error)

TriggerTypingIndicator [REST] Post a typing indicator for the specified channel. Generally bots should not implement this route. However, if a bot is responding to a command and expects the computation to take a few seconds, this endpoint may be called to let the user know that the bot is processing their message. Returns a 204 empty response on success. Fires a Typing Start Gateway event.

Method                  POST
Endpoint                /Channels/{channel.id}/typing
Discord documentation   https://discordapp.com/developers/docs/resources/channel#trigger-typing-indicator
Reviewed                2018-06-10
Comment                 -

func (*Client) UnbanMember

func (c *Client) UnbanMember(ctx context.Context, guildID, userID Snowflake, reason string, flags ...Flag) (err error)

UnbanMember [REST] Remove the ban for a user. Requires the 'BAN_MEMBERS' permissions. Returns a 204 empty response on success. Fires a Guild Ban Remove Gateway event.

Method                  DELETE
Endpoint                /Guilds/{guild.id}/bans/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#remove-guild-ban
Reviewed                2018-08-18
Comment                 -

func (*Client) UnpinMessage

func (c *Client) UnpinMessage(ctx context.Context, message *Message, flags ...Flag) error

UnpinMessage see Client.UnpinMessageID

func (*Client) UnpinMessageID

func (c *Client) UnpinMessageID(ctx context.Context, channelID, messageID Snowflake, flags ...Flag) (err error)

UnpinMessageID [REST] Delete a pinned message in a channel. Requires the 'MANAGE_MESSAGES' permission. Returns a 204 empty response on success. Returns a 204 empty response on success.

Method                  DELETE
Endpoint                /Channels/{channel.id}/pins/{message.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#delete-pinned-channel-message
Reviewed                2018-06-10
Comment                 -

func (*Client) UpdateChannel

func (c *Client) UpdateChannel(ctx context.Context, channelID Snowflake, flags ...Flag) (builder *updateChannelBuilder)

UpdateChannel [REST] Update a Channels settings. Requires the 'MANAGE_CHANNELS' permission for the guild. Returns a channel on success, and a 400 BAD REQUEST on invalid parameters. Fires a Channel Update Gateway event. If modifying a category, individual Channel Update events will fire for each child channel that also changes. For the PATCH method, all the JSON Params are optional.

Method                  PUT/PATCH
Endpoint                /Channels/{channel.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#modify-channel
Reviewed                2018-06-07
Comment                 andersfylling: only implemented the patch method, as its parameters are optional.

func (*Client) UpdateChannelPermissions

func (c *Client) UpdateChannelPermissions(ctx context.Context, channelID, overwriteID Snowflake, params *UpdateChannelPermissionsParams, flags ...Flag) (err error)

EditChannelPermissions [REST] Edit the channel permission overwrites for a user or role in a channel. Only usable for guild Channels. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success. For more information about permissions, see permissions.

Method                  PUT
Endpoint                /Channels/{channel.id}/permissions/{overwrite.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#edit-channel-permissions
Reviewed                2018-06-07
Comment                 -

func (*Client) UpdateCurrentUser

func (c *Client) UpdateCurrentUser(ctx context.Context, flags ...Flag) (builder *updateCurrentUserBuilder)

UpdateCurrentUser [REST] Modify the requester's user account settings. Returns a user object on success.

Method                  PATCH
Endpoint                /Users/@me
Discord documentation   https://discordapp.com/developers/docs/resources/user#modify-current-user
Reviewed                2019-02-18
Comment                 -

func (*Client) UpdateGuild

func (c *Client) UpdateGuild(ctx context.Context, id Snowflake, flags ...Flag) (builder *updateGuildBuilder)

ModifyGuild [REST] Modify a guild's settings. Requires the 'MANAGE_GUILD' permission. Returns the updated guild object on success. Fires a Guild Update Gateway event.

Method                  PATCH
Endpoint                /Guilds/{guild.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild
Reviewed                2018-08-17
Comment                 All parameters to this endpoint. are optional

func (*Client) UpdateGuildChannelPositions

func (c *Client) UpdateGuildChannelPositions(ctx context.Context, guildID Snowflake, params []UpdateGuildChannelPositionsParams, flags ...Flag) (err error)

UpdateGuildChannelPositions [REST] Modify the positions of a set of channel objects for the guild. Requires 'MANAGE_CHANNELS' permission. Returns a 204 empty response on success. Fires multiple Channel Update Gateway events.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/Channels
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild-channel-positions
Reviewed                2018-08-17
Comment                 Only Channels to be modified are required, with the minimum being a swap
                        between at least two Channels.

func (*Client) UpdateGuildEmbed

func (c *Client) UpdateGuildEmbed(ctx context.Context, guildID Snowflake, flags ...Flag) (builder *updateGuildEmbedBuilder)

UpdateGuildEmbed [REST] Modify a guild embed object for the guild. All attributes may be passed in with JSON and modified. Requires the 'MANAGE_GUILD' permission. Returns the updated guild embed object.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/embed
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild-embed
Reviewed                2018-08-18
Comment                 -

func (*Client) UpdateGuildEmoji

func (c *Client) UpdateGuildEmoji(ctx context.Context, guildID, emojiID Snowflake, flags ...Flag) (builder *updateGuildEmojiBuilder)

UpdateGuildEmoji [REST] Modify the given emoji. Requires the 'MANAGE_EMOJIS' permission. Returns the updated emoji object on success. Fires a Guild Emojis Update Gateway event.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/emojis/{emoji.id}
Discord documentation   https://discordapp.com/developers/docs/resources/emoji#modify-guild-emoji
Reviewed                2019-02-20
Comment                 -

func (*Client) UpdateGuildIntegration

func (c *Client) UpdateGuildIntegration(ctx context.Context, guildID, integrationID Snowflake, params *UpdateGuildIntegrationParams, flags ...Flag) (err error)

UpdateGuildIntegration [REST] Modify the behavior and settings of a integration object for the guild. Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success. Fires a Guild Integrations Update Gateway event.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/integrations/{integration.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild-integration
Reviewed                2018-08-18
Comment                 -

func (*Client) UpdateGuildMember

func (c *Client) UpdateGuildMember(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (builder *updateGuildMemberBuilder)

UpdateGuildMember [REST] Modify attributes of a guild member. Returns a 204 empty response on success. Fires a Guild Member Update Gateway event.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/members/{user.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild-member
Reviewed                2018-08-17
Comment                 All parameters to this endpoint. are optional. When moving members to Channels,
                        the API user must have permissions to both connect to the channel and have the
                        MOVE_MEMBERS permission.

func (*Client) UpdateGuildRole

func (c *Client) UpdateGuildRole(ctx context.Context, guildID, roleID Snowflake, flags ...Flag) (builder *updateGuildRoleBuilder)

ModifyGuildRole [REST] Modify a guild role. Requires the 'MANAGE_ROLES' permission. Returns the updated role on success. Fires a Guild Role Update Gateway event.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/roles/{role.id}
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild-role
Reviewed                2018-08-18
Comment                 -

func (*Client) UpdateGuildRolePositions

func (c *Client) UpdateGuildRolePositions(ctx context.Context, guildID Snowflake, params []UpdateGuildRolePositionsParams, flags ...Flag) (roles []*Role, err error)

UpdateGuildRolePositions [REST] Modify the positions of a set of role objects for the guild. Requires the 'MANAGE_ROLES' permission. Returns a list of all of the guild's role objects on success. Fires multiple Guild Role Update Gateway events.

Method                  PATCH
Endpoint                /Guilds/{guild.id}/roles
Discord documentation   https://discordapp.com/developers/docs/resources/guild#modify-guild-role-positions
Reviewed                2018-08-18
Comment                 -

func (*Client) UpdateMessage

func (c *Client) UpdateMessage(ctx context.Context, chanID, msgID Snowflake, flags ...Flag) (builder *updateMessageBuilder)

UpdateMessage [REST] Edit a previously sent message. You can only edit messages that have been sent by the current user. Returns a message object. Fires a Message Update Gateway event.

Method                  PATCH
Endpoint                /Channels/{channel.id}/messages/{message.id}
Discord documentation   https://discordapp.com/developers/docs/resources/channel#edit-message
Reviewed                2018-06-10
Comment                 All parameters to this endpoint are optional.

TODO: verify embed is working

func (*Client) UpdateStatus

func (c *Client) UpdateStatus(s *UpdateStatusPayload) error

UpdateStatus updates the Client's game status note: for simple games, check out UpdateStatusString

func (*Client) UpdateStatusString

func (c *Client) UpdateStatusString(s string) error

UpdateStatusString sets the Client's game activity to the provided string, status to online and type to Playing

func (*Client) UpdateWebhook

func (c *Client) UpdateWebhook(ctx context.Context, id Snowflake, flags ...Flag) (builder *updateWebhookBuilder)

UpdateWebhook [REST] Modify a webhook. Requires the 'MANAGE_WEBHOOKS' permission. Returns the updated webhook object on success.

Method                  PATCH
Endpoint                /webhooks/{webhook.id}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#modify-webhook
Reviewed                2018-08-14
Comment                 All parameters to this endpoint.

func (*Client) UpdateWebhookWithToken

func (c *Client) UpdateWebhookWithToken(ctx context.Context, id Snowflake, token string, flags ...Flag) (builder *updateWebhookBuilder)

UpdateWebhookWithToken [REST] Same as UpdateWebhook, except this call does not require authentication, does _not_ accept a channel_id parameter in the body, and does not return a user in the webhook object.

Method                  PATCH
Endpoint                /webhooks/{webhook.id}/{webhook.token}
Discord documentation   https://discordapp.com/developers/docs/resources/webhook#modify-webhook-with-token
Reviewed                2018-08-14
Comment                 All parameters to this endpoint. are optional.

func (Client) VoiceConnect

func (r Client) VoiceConnect(guildID, channelID Snowflake) (VoiceConnection, error)

func (Client) VoiceConnectOptions

func (r Client) VoiceConnectOptions(guildID, channelID Snowflake, selfDeaf, selfMute bool) (ret VoiceConnection, err error)

type CloseConnectionErr

type CloseConnectionErr = disgorderr.ClosedConnectionErr

type Config

type Config struct {
	// ################################################
	// ##
	// ## Basic bot configuration.
	// ## This section is for everyone. And beginners
	// ## should stick to this section unless they know
	// ## what they are doing.
	// ##
	// ################################################
	BotToken   string
	HTTPClient *http.Client
	Proxy      proxy.Dialer

	CancelRequestWhenRateLimited bool

	// LoadMembersQuietly will start fetching members for all Guilds in the background.
	// There is currently no proper way to detect when the loading is done nor if it
	// finished successfully.
	LoadMembersQuietly bool

	// Presence will automatically be emitted to discord on start up
	Presence *UpdateStatusPayload

	// your project name, name of bot, or application
	ProjectName string

	// Logger is a dependency that must be injected to support logging.
	// disgord.DefaultLogger() can be used
	Logger Logger

	// ################################################
	// ##
	// ## WARNING! For advanced Users only.
	// ## This section of options might break the bot,
	// ## make it incoherent to the Discord API requirements,
	// ## potentially causing your bot to be banned.
	// ## You use these features on your own risk.
	// ##
	// ################################################
	RESTBucketManager httd.RESTBucketManager

	DisableCache bool
	CacheConfig  *CacheConfig
	ShardConfig  ShardConfig

	// IgnoreEvents will skip events that matches the given event names.
	// WARNING! This can break your caching, so be careful about what you want to ignore.
	//
	// Note this also triggers discord optimizations behind the scenes, such that disgord_diagnosews might
	// seem to be missing some events. But actually the lack of certain events will mean Discord aren't sending
	// them at all due to how the identify command was defined. eg. guildS_subscriptions
	IgnoreEvents []string
	// contains filtered or unexported fields
}

Config Configuration for the Disgord Client

type Copier

type Copier interface {
	CopyOverTo(other interface{}) error
}

Copier holds the CopyOverTo method which copies all it's content from one struct to another. Note that this requires a deep copy. useful when overwriting already existing content in the cacheLink to reduce GC.

type CreateChannelInvitesParams

type CreateChannelInvitesParams struct {
	MaxAge    int  `json:"max_age,omitempty"`   // duration of invite in seconds before expiry, or 0 for never. default 86400 (24 hours)
	MaxUses   int  `json:"max_uses,omitempty"`  // max number of uses or 0 for unlimited. default 0
	Temporary bool `json:"temporary,omitempty"` // whether this invite only grants temporary membership. default false
	Unique    bool `json:"unique,omitempty"`    // if true, don't try to reuse a similar invite (useful for creating many unique one time use invites). default false

	// Reason is a X-Audit-Log-Reason header field that will show up on the audit log for this action.
	Reason string `json:"-"`
}

CreateChannelInvitesParams https://discordapp.com/developers/docs/resources/channel#create-channel-invite-json-params

type CreateGroupDMParams

type CreateGroupDMParams struct {
	// AccessTokens access tokens of Users that have granted your app the gdm.join scope
	AccessTokens []string `json:"access_tokens"`

	// map[userID] = nickname
	Nicks map[Snowflake]string `json:"nicks"`
}

CreateGroupDMParams required JSON params for func CreateGroupDM https://discordapp.com/developers/docs/resources/user#create-group-dm

type CreateGuildChannelParams

type CreateGuildChannelParams struct {
	Name                 string                `json:"name"` // required
	Type                 uint                  `json:"type,omitempty"`
	Topic                string                `json:"topic,omitempty"`
	Bitrate              uint                  `json:"bitrate,omitempty"`
	UserLimit            uint                  `json:"user_limit,omitempty"`
	RateLimitPerUser     uint                  `json:"rate_limit_per_user,omitempty"`
	PermissionOverwrites []PermissionOverwrite `json:"permission_overwrites,omitempty"`
	ParentID             Snowflake             `json:"parent_id,omitempty"`
	NSFW                 bool                  `json:"nsfw,omitempty"`
	Position             int                   `json:"position"` // can not omitempty in case position is 0

	// Reason is a X-Audit-Log-Reason header field that will show up on the audit log for this action.
	Reason string `json:"-"`
}

CreateGuildChannelParams https://discordapp.com/developers/docs/resources/guild#create-guild-channel-json-params

type CreateGuildEmojiParams

type CreateGuildEmojiParams struct {
	Name  string      `json:"name"`  // required
	Image string      `json:"image"` // required
	Roles []Snowflake `json:"roles"` // optional

	// Reason is a X-Audit-Log-Reason header field that will show up on the audit log for this action.
	Reason string `json:"-"`
}

CreateGuildEmojiParams JSON params for func CreateGuildEmoji

type CreateGuildIntegrationParams

type CreateGuildIntegrationParams struct {
	Type string    `json:"type"`
	ID   Snowflake `json:"id"`
}

CreateGuildIntegrationParams ... https://discordapp.com/developers/docs/resources/guild#create-guild-integration-json-params

type CreateGuildParams

type CreateGuildParams struct {
	Name                    string                        `json:"name"` // required
	Region                  string                        `json:"region"`
	Icon                    string                        `json:"icon"`
	VerificationLvl         int                           `json:"verification_level"`
	DefaultMsgNotifications DefaultMessageNotificationLvl `json:"default_message_notifications"`
	ExplicitContentFilter   ExplicitContentFilterLvl      `json:"explicit_content_filter"`
	Roles                   []*Role                       `json:"roles"`
	Channels                []*PartialChannel             `json:"Channels"`
}

CreateGuildParams ... https://discordapp.com/developers/docs/resources/guild#create-guild-json-params example partial channel object: {

"name": "naming-things-is-hard",
"type": 0

}

type CreateGuildRoleParams

type CreateGuildRoleParams struct {
	Name        string `json:"name,omitempty"`
	Permissions uint64 `json:"permissions,omitempty"`
	Color       uint   `json:"color,omitempty"`
	Hoist       bool   `json:"hoist,omitempty"`
	Mentionable bool   `json:"mentionable,omitempty"`

	// Reason is a X-Audit-Log-Reason header field that will show up on the audit log for this action.
	Reason string `json:"-"`
}

CreateGuildRoleParams ... https://discordapp.com/developers/docs/resources/guild#create-guild-role-json-params

type CreateMessageFileParams

type CreateMessageFileParams struct {
	Reader   io.Reader `json:"-"` // always omit as we don't want this as part of the JSON payload
	FileName string    `json:"-"`

	// SpoilerTag lets discord know that this image should be blurred out.
	// Current Discord behaviour is that whenever a message with one or more images is marked as
	// spoiler tag, all the images in that message are blurred out. (independent of msg.Content)
	SpoilerTag bool `json:"-"`
}

CreateMessageFileParams contains the information needed to upload a file to Discord, it is part of the CreateMessageParams struct.

type CreateMessageParams

type CreateMessageParams struct {
	Content string `json:"content"`
	Nonce   string `json:"nonce,omitempty"` // THIS IS A STRING. NOT A SNOWFLAKE! DONT TOUCH!
	Tts     bool   `json:"tts,omitempty"`
	Embed   *Embed `json:"embed,omitempty"` // embedded rich content

	Files []CreateMessageFileParams `json:"-"` // Always omit as this is included in multipart, not JSON payload

	SpoilerTagContent        bool `json:"-"`
	SpoilerTagAllAttachments bool `json:"-"`
}

CreateMessageParams JSON params for CreateChannelMessage

func NewMessageByString

func NewMessageByString(content string) *CreateMessageParams

NewMessageByString creates a message object from a string/content

type CreateWebhookParams

type CreateWebhookParams struct {
	Name   string `json:"name"`   // name of the webhook (2-32 characters)
	Avatar string `json:"avatar"` // avatar data uri scheme, image for the default webhook avatar

	// Reason is a X-Audit-Log-Reason header field that will show up on the audit log for this action.
	Reason string `json:"-"`
}

CreateWebhookParams json params for the create webhook rest request avatar string https://discordapp.com/developers/docs/resources/user#avatar-data

func (*CreateWebhookParams) FindErrors

func (c *CreateWebhookParams) FindErrors() error

type Ctrl

type Ctrl struct {
	Runs     int
	Until    time.Time
	Duration time.Duration
	Channel  interface{}
}

Ctrl is a handler controller that supports lifetime and max number of execution for one or several handlers.

// register only the first 6 votes
Client.On("MESSAGE_CREATE", filter.NonVotes, registerVoteHandler, &disgord.Ctrl{Runs: 6})

// Allow voting for only 10 minutes
Client.On("MESSAGE_CREATE", filter.NonVotes, registerVoteHandler, &disgord.Ctrl{Duration: 10*time.Second})

// Allow voting until the month is over
Client.On("MESSAGE_CREATE", filter.NonVotes, registerVoteHandler, &disgord.Ctrl{Until: time.Now().AddDate(0, 1, 0)})

func (*Ctrl) CloseChannel

func (c *Ctrl) CloseChannel()

CloseChannel must be called instead of closing an event channel directly. This is to make sure Disgord does not go into a deadlock

func (*Ctrl) IsDead

func (c *Ctrl) IsDead() bool

func (*Ctrl) OnInsert

func (c *Ctrl) OnInsert(Session) error

func (*Ctrl) OnRemove

func (c *Ctrl) OnRemove(Session) error

func (*Ctrl) Update

func (c *Ctrl) Update()

type DeepCopier

type DeepCopier interface {
	DeepCopy() interface{}
}

DeepCopier holds the DeepCopy method which creates and returns a deep copy of any struct.

type DefaultMessageNotificationLvl

type DefaultMessageNotificationLvl uint

DefaultMessageNotificationLvl ... https://discordapp.com/developers/docs/resources/guild#guild-object-default-message-notification-level

const (
	DefaultMessageNotificationLvlAllMessages DefaultMessageNotificationLvl = iota
	DefaultMessageNotificationLvlOnlyMentions
)

different notification levels on new messages

func (*DefaultMessageNotificationLvl) AllMessages

func (dmnl *DefaultMessageNotificationLvl) AllMessages() bool

AllMessages ...

func (*DefaultMessageNotificationLvl) OnlyMentions

func (dmnl *DefaultMessageNotificationLvl) OnlyMentions() bool

OnlyMentions ...

type DeleteMessagesParams

type DeleteMessagesParams struct {
	Messages []Snowflake `json:"messages"`
	// contains filtered or unexported fields
}

DeleteMessagesParams https://discordapp.com/developers/docs/resources/channel#bulk-delete-messages-json-params

func (*DeleteMessagesParams) AddMessage

func (p *DeleteMessagesParams) AddMessage(msg *Message) (err error)

AddMessage Adds a message to be deleted

func (*DeleteMessagesParams) Valid

func (p *DeleteMessagesParams) Valid() (err error)

Valid validates the DeleteMessagesParams data

type Discriminator

type Discriminator uint16

Discriminator value

func NewDiscriminator

func NewDiscriminator(d string) (discriminator Discriminator, err error)

NewDiscriminator Discord user discriminator hashtag

func (Discriminator) MarshalJSON

func (d Discriminator) MarshalJSON() (data []byte, err error)

MarshalJSON see interface json.Marshaler

func (Discriminator) NotSet

func (d Discriminator) NotSet() bool

NotSet checks if the discriminator is not set

func (Discriminator) String

func (d Discriminator) String() (str string)

func (*Discriminator) UnmarshalJSON

func (d *Discriminator) UnmarshalJSON(data []byte) (err error)

UnmarshalJSON see interface json.Unmarshaler

type Embed

type Embed struct {
	Lockable `json:"-"`

	Title       string          `json:"title,omitempty"`       // title of embed
	Type        string          `json:"type,omitempty"`        // type of embed (always "rich" for webhook embeds)
	Description string          `json:"description,omitempty"` // description of embed
	URL         string          `json:"url,omitempty"`         // url of embed
	Timestamp   Time            `json:"timestamp,omitempty"`   // timestamp	timestamp of embed content
	Color       int             `json:"color"`                 // color code of the embed
	Footer      *EmbedFooter    `json:"footer,omitempty"`      // embed footer object	footer information
	Image       *EmbedImage     `json:"image,omitempty"`       // embed image object	image information
	Thumbnail   *EmbedThumbnail `json:"thumbnail,omitempty"`   // embed thumbnail object	thumbnail information
	Video       *EmbedVideo     `json:"video,omitempty"`       // embed video object	video information
	Provider    *EmbedProvider  `json:"provider,omitempty"`    // embed provider object	provider information
	Author      *EmbedAuthor    `json:"author,omitempty"`      // embed author object	author information
	Fields      []*EmbedField   `json:"fields,omitempty"`      //	array of embed field objects	fields information
}

Embed https://discordapp.com/developers/docs/resources/channel#embed-object

func (*Embed) CopyOverTo

func (c *Embed) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Embed) DeepCopy

func (c *Embed) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedAuthor

type EmbedAuthor struct {
	Lockable `json:"-"`

	Name         string `json:"name,omitempty"`           // ?| , name of author
	URL          string `json:"url,omitempty"`            // ?| , url of author
	IconURL      string `json:"icon_url,omitempty"`       // ?| , url of author icon (only supports http(s) and attachments)
	ProxyIconURL string `json:"proxy_icon_url,omitempty"` // ?| , a proxied url of author icon
}

EmbedAuthor https://discordapp.com/developers/docs/resources/channel#embed-object-embed-author-structure

func (*EmbedAuthor) CopyOverTo

func (c *EmbedAuthor) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedAuthor) DeepCopy

func (c *EmbedAuthor) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedField

type EmbedField struct {
	Lockable `json:"-"`

	Name   string `json:"name"`             //  | , name of the field
	Value  string `json:"value"`            //  | , value of the field
	Inline bool   `json:"inline,omitempty"` // ?| , whether or not this field should display inline
}

EmbedField https://discordapp.com/developers/docs/resources/channel#embed-object-embed-field-structure

func (*EmbedField) CopyOverTo

func (c *EmbedField) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedField) DeepCopy

func (c *EmbedField) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedFooter

type EmbedFooter struct {
	Lockable `json:"-"`

	Text         string `json:"text"`                     //  | , url of author
	IconURL      string `json:"icon_url,omitempty"`       // ?| , url of footer icon (only supports http(s) and attachments)
	ProxyIconURL string `json:"proxy_icon_url,omitempty"` // ?| , a proxied url of footer icon
}

EmbedFooter https://discordapp.com/developers/docs/resources/channel#embed-object-embed-footer-structure

func (*EmbedFooter) CopyOverTo

func (c *EmbedFooter) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedFooter) DeepCopy

func (c *EmbedFooter) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedImage

type EmbedImage struct {
	Lockable `json:"-"`

	URL      string `json:"url,omitempty"`       // ?| , source url of image (only supports http(s) and attachments)
	ProxyURL string `json:"proxy_url,omitempty"` // ?| , a proxied url of the image
	Height   int    `json:"height,omitempty"`    // ?| , height of image
	Width    int    `json:"width,omitempty"`     // ?| , width of image
}

EmbedImage https://discordapp.com/developers/docs/resources/channel#embed-object-embed-image-structure

func (*EmbedImage) CopyOverTo

func (c *EmbedImage) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedImage) DeepCopy

func (c *EmbedImage) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedProvider

type EmbedProvider struct {
	Lockable `json:"-"`

	Name string `json:"name,omitempty"` // ?| , name of provider
	URL  string `json:"url,omitempty"`  // ?| , url of provider
}

EmbedProvider https://discordapp.com/developers/docs/resources/channel#embed-object-embed-provider-structure

func (*EmbedProvider) CopyOverTo

func (c *EmbedProvider) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedProvider) DeepCopy

func (c *EmbedProvider) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedThumbnail

type EmbedThumbnail struct {
	Lockable `json:"-"`

	URL      string `json:"url,omitempty"`       // ?| , source url of image (only supports http(s) and attachments)
	ProxyURL string `json:"proxy_url,omitempty"` // ?| , a proxied url of the image
	Height   int    `json:"height,omitempty"`    // ?| , height of image
	Width    int    `json:"width,omitempty"`     // ?| , width of image
}

EmbedThumbnail https://discordapp.com/developers/docs/resources/channel#embed-object-embed-thumbnail-structure

func (*EmbedThumbnail) CopyOverTo

func (c *EmbedThumbnail) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedThumbnail) DeepCopy

func (c *EmbedThumbnail) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type EmbedVideo

type EmbedVideo struct {
	Lockable `json:"-"`

	URL    string `json:"url,omitempty"`    // ?| , source url of video
	Height int    `json:"height,omitempty"` // ?| , height of video
	Width  int    `json:"width,omitempty"`  // ?| , width of video
}

EmbedVideo https://discordapp.com/developers/docs/resources/channel#embed-object-embed-video-structure

func (*EmbedVideo) CopyOverTo

func (c *EmbedVideo) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*EmbedVideo) DeepCopy

func (c *EmbedVideo) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type Emitter

type Emitter interface {
	Emit(name gatewayCmdName, data gatewayCmdPayload) (unhandledGuildIDs []Snowflake, err error)
}

Emitter for emitting data from A to B. Used in websocket connection

type Emoji

type Emoji struct {
	ID            Snowflake   `json:"id"`
	Name          string      `json:"name"`
	Roles         []Snowflake `json:"roles,omitempty"`
	User          *User       `json:"user,omitempty"` // the user who created the emoji
	RequireColons bool        `json:"require_colons,omitempty"`
	Managed       bool        `json:"managed,omitempty"`
	Animated      bool        `json:"animated,omitempty"`
	// contains filtered or unexported fields
}

Emoji ...

func (*Emoji) CopyOverTo

func (e *Emoji) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Emoji) DeepCopy

func (e *Emoji) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*Emoji) LinkToGuild

func (e *Emoji) LinkToGuild(guildID Snowflake)

func (*Emoji) Mention

func (e *Emoji) Mention() string

Mention mentions an emoji. Adds the animation prefix, if animated

func (*Emoji) Reset

func (e *Emoji) Reset()

func (*Emoji) String

func (e *Emoji) String() string

type EmojiName

type EmojiName struct {
	// contains filtered or unexported fields
}

func (EmojiName) String

func (e EmojiName) String() string

Parse string to unicode

type Err

type Err = disgorderr.Err

TODO: go generate from internal/errors/*

type ErrRest

type ErrRest = httd.ErrREST

type ErrorCacheItemNotFound

type ErrorCacheItemNotFound struct {
	// contains filtered or unexported fields
}

ErrorCacheItemNotFound requested item was not found in cacheLink

func (*ErrorCacheItemNotFound) Error

func (e *ErrorCacheItemNotFound) Error() string

Error ...

type ErrorEmptyValue

type ErrorEmptyValue struct {
	// contains filtered or unexported fields
}

ErrorEmptyValue when a required value was set as empty

func (*ErrorEmptyValue) Error

func (e *ErrorEmptyValue) Error() string

type ErrorMissingSnowflake

type ErrorMissingSnowflake struct {
	// contains filtered or unexported fields
}

ErrorMissingSnowflake used by methods about to communicate with the Discord API. If a snowflake value is required this is used to identify that you must set the value before being able to interact with the Discord API

func (*ErrorMissingSnowflake) Error

func (e *ErrorMissingSnowflake) Error() string

type ErrorUnsupportedType

type ErrorUnsupportedType struct {
	// contains filtered or unexported fields
}

ErrorUnsupportedType used when the given param type is not supported

func (*ErrorUnsupportedType) Error

func (e *ErrorUnsupportedType) Error() string

type ErrorUsingDeactivatedCache

type ErrorUsingDeactivatedCache struct {
	// contains filtered or unexported fields
}

ErrorUsingDeactivatedCache the cacheLink system you are trying to access has been disabled in the CacheConfig

func (*ErrorUsingDeactivatedCache) Error

type ExecuteWebhookParams

type ExecuteWebhookParams struct {
	WebhookID Snowflake `json:"-"`
	Token     string    `json:"-"`

	Content   string      `json:"content"`
	Username  string      `json:"username"`
	AvatarURL string      `json:"avatar_url"`
	TTS       bool        `json:"tts"`
	File      interface{} `json:"file"`
	Embeds    []*Embed    `json:"embeds"`
}

ExecuteWebhookParams JSON params for func ExecuteWebhook

func NewExecuteWebhookParams

func NewExecuteWebhookParams(id Snowflake, token string) (ret *ExecuteWebhookParams, err error)

NewExecuteWebhookParams creates params for func ExecuteWebhook

type ExplicitContentFilterLvl

type ExplicitContentFilterLvl uint

ExplicitContentFilterLvl ... https://discordapp.com/developers/docs/resources/guild#guild-object-explicit-content-filter-level

const (
	ExplicitContentFilterLvlDisabled ExplicitContentFilterLvl = iota
	ExplicitContentFilterLvlMembersWithoutRoles
	ExplicitContentFilterLvlAllMembers
)

Explicit content filter levels

func (*ExplicitContentFilterLvl) AllMembers

func (ecfl *ExplicitContentFilterLvl) AllMembers() bool

AllMembers if the filter applies for all members regardles of them having a role or not

func (*ExplicitContentFilterLvl) Disabled

func (ecfl *ExplicitContentFilterLvl) Disabled() bool

Disabled if the content filter is disabled

func (*ExplicitContentFilterLvl) MembersWithoutRoles

func (ecfl *ExplicitContentFilterLvl) MembersWithoutRoles() bool

MembersWithoutRoles if the filter only applies for members without a role

type Flag

type Flag uint32
const (
	IgnoreCache Flag = 1 << iota
	IgnoreEmptyParams

	// sort options
	SortByID
	SortByName
	SortByHoist
	SortByGuildID
	SortByChannelID

	// ordering
	OrderAscending // default when sorting
	OrderDescending
)

func (Flag) IgnoreEmptyParams

func (f Flag) IgnoreEmptyParams() bool

func (Flag) Ignorecache

func (f Flag) Ignorecache() bool

func (Flag) Sort

func (f Flag) Sort() bool

func (Flag) String

func (i Flag) String() string

type GetCurrentUserGuildsParams

type GetCurrentUserGuildsParams struct {
	Before Snowflake `urlparam:"before,omitempty"`
	After  Snowflake `urlparam:"after,omitempty"`
	Limit  int       `urlparam:"limit,omitempty"`
}

GetCurrentUserGuildsParams JSON params for func GetCurrentUserGuilds

func (*GetCurrentUserGuildsParams) URLQueryString

func (g *GetCurrentUserGuildsParams) URLQueryString() string

type GetInviteParams

type GetInviteParams struct {
	WithMemberCount bool `urlparam:"with_count,omitempty"`
}

func (*GetInviteParams) URLQueryString

func (g *GetInviteParams) URLQueryString() string

type GetMembersParams

type GetMembersParams struct {
	After Snowflake `urlparam:"after,omitempty"`
	Limit uint32    `urlparam:"limit,omitempty"` // 0 will fetch everyone
}

GetMembersParams if Limit is 0, every member is fetched. This does not follow the Discord API where a 0 is converted into a 1. 0 = every member. The rest is exactly the same, you should be able to do everything the Discord docs says with the addition that you can bypass a limit of 1,000.

If you specify a limit of +1,000 Disgord will run N requests until that amount is met, or until you run out of members to fetch.

type GetMessagesParams

type GetMessagesParams struct {
	Around Snowflake `urlparam:"around,omitempty"`
	Before Snowflake `urlparam:"before,omitempty"`
	After  Snowflake `urlparam:"after,omitempty"`
	Limit  uint      `urlparam:"limit,omitempty"`
}

GetChannelMessagesParams https://discordapp.com/developers/docs/resources/channel#get-channel-messages-query-string-params TODO: ensure limits

func (*GetMessagesParams) URLQueryString

func (g *GetMessagesParams) URLQueryString() string

func (*GetMessagesParams) Validate

func (p *GetMessagesParams) Validate() error

type GetReactionURLParams

type GetReactionURLParams struct {
	Before Snowflake `urlparam:"before,omitempty"` // get Users before this user Snowflake
	After  Snowflake `urlparam:"after,omitempty"`  // get Users after this user Snowflake
	Limit  int       `urlparam:"limit,omitempty"`  // max number of Users to return (1-100)
}

GetReactionURLParams https://discordapp.com/developers/docs/resources/channel#get-reactions-query-string-params

func (*GetReactionURLParams) URLQueryString

func (g *GetReactionURLParams) URLQueryString() string

type GroupDMParticipant

type GroupDMParticipant struct {
	AccessToken string    `json:"access_token"`   // access token of a user that has granted your app the gdm.join scope
	Nickname    string    `json:"nick,omitempty"` // nickname of the user being added
	UserID      Snowflake `json:"-"`
}

GroupDMParticipant Information needed to add a recipient to a group chat

func (*GroupDMParticipant) FindErrors

func (g *GroupDMParticipant) FindErrors() error

type Guild

type Guild struct {
	Lockable `json:"-"`

	ID                          Snowflake                     `json:"id"`
	ApplicationID               Snowflake                     `json:"application_id"` //   |?
	Name                        string                        `json:"name"`
	Icon                        string                        `json:"icon"`            //  |?, icon hash
	Splash                      string                        `json:"splash"`          //  |?, image hash
	Owner                       bool                          `json:"owner,omitempty"` // ?|
	OwnerID                     Snowflake                     `json:"owner_id"`
	Permissions                 PermissionBits                `json:"permissions,omitempty"` // ?|, permission flags for connected user `/Users/@me/Guilds`
	Region                      string                        `json:"region"`
	AfkChannelID                Snowflake                     `json:"afk_channel_id"` // |?
	AfkTimeout                  uint                          `json:"afk_timeout"`
	EmbedEnabled                bool                          `json:"embed_enabled,omit_empty"`
	EmbedChannelID              Snowflake                     `json:"embed_channel_id,omit_empty"`
	VerificationLevel           VerificationLvl               `json:"verification_level"`
	DefaultMessageNotifications DefaultMessageNotificationLvl `json:"default_message_notifications"`
	ExplicitContentFilter       ExplicitContentFilterLvl      `json:"explicit_content_filter"`
	Roles                       []*Role                       `json:"roles"`
	Emojis                      []*Emoji                      `json:"emojis"`
	Features                    []string                      `json:"features"`
	MFALevel                    MFALvl                        `json:"mfa_level"`
	WidgetEnabled               bool                          `json:"widget_enabled,omit_empty"`    //   |
	WidgetChannelID             Snowflake                     `json:"widget_channel_id,omit_empty"` //   |?
	SystemChannelID             Snowflake                     `json:"system_channel_id,omitempty"`  //   |?

	// JoinedAt must be a pointer, as we can't hide non-nil structs
	JoinedAt    *Time           `json:"joined_at,omitempty"`    // ?*|
	Large       bool            `json:"large,omitempty"`        // ?*|
	Unavailable bool            `json:"unavailable"`            // ?*| omitempty?
	MemberCount uint            `json:"member_count,omitempty"` // ?*|
	VoiceStates []*VoiceState   `json:"voice_states,omitempty"` // ?*|
	Members     []*Member       `json:"members,omitempty"`      // ?*|
	Channels    []*Channel      `json:"Channels,omitempty"`     // ?*|
	Presences   []*UserPresence `json:"presences,omitempty"`    // ?*|

}

Guild Guilds in Discord represent an isolated collection of Users and Channels,

and are often referred to as "servers" in the UI.

https://discordapp.com/developers/docs/resources/guild#guild-object Fields with `*` are only sent within the GUILD_CREATE event reviewed: 2018-08-25

func NewGuild

func NewGuild() *Guild

NewGuild ...

func NewGuildFromJSON

func NewGuildFromJSON(data []byte) (guild *Guild)

NewGuildFromJSON ...

func NewGuildFromUnavailable

func NewGuildFromUnavailable(gu *GuildUnavailable) *Guild

NewGuildFromUnavailable converts a unavailable guild object into a normal Guild object

func NewPartialGuild

func NewPartialGuild(ID Snowflake) (guild *Guild)

NewPartialGuild ...

func (*Guild) AddChannel

func (g *Guild) AddChannel(c *Channel) error

AddChannel adds a channel to the Guild object. Note that this method does not interact with Discord.

func (*Guild) AddMember

func (g *Guild) AddMember(member *Member) error

AddMember adds a member to the Guild object. Note that this method does not interact with Discord.

func (*Guild) AddMembers

func (g *Guild) AddMembers(members []*Member)

AddMembers adds multiple members to the Guild object. Note that this method does not interact with Discord.

func (*Guild) AddRole

func (g *Guild) AddRole(role *Role) error

AddRole adds a role to the Guild object. Note that this does not interact with Discord.

func (*Guild) Channel

func (g *Guild) Channel(id Snowflake) (*Channel, error)

Channel get a guild channel given it's ID

func (*Guild) CopyOverTo

func (g *Guild) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Guild) DeepCopy

func (g *Guild) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*Guild) DeleteChannel

func (g *Guild) DeleteChannel(c *Channel) error

DeleteChannel removes a channel from the Guild object. Note that this method does not interact with Discord.

func (*Guild) DeleteChannelByID

func (g *Guild) DeleteChannelByID(ID Snowflake) error

DeleteChannelByID removes a channel from the Guild object. Note that this method does not interact with Discord.

func (*Guild) DeleteRoleByID

func (g *Guild) DeleteRoleByID(ID Snowflake)

DeleteRoleByID remove a role from the guild struct

func (*Guild) Emoji

func (g *Guild) Emoji(id Snowflake) (emoji *Emoji, err error)

Emoji get a guild emoji by it's ID

func (*Guild) GetMemberWithHighestSnowflake

func (g *Guild) GetMemberWithHighestSnowflake() *Member

GetMemberWithHighestSnowflake finds the member with the highest snowflake value.

func (*Guild) GetMembersCountEstimate

func (g *Guild) GetMembersCountEstimate(ctx context.Context, s Session) (estimate int, err error)

GetMembersCountEstimate estimates the number of members in a guild without fetching everyone. There is no proper way to get this number, so a invite is created and the estimate is read from there. The invite is then deleted again.

func (*Guild) MarshalJSON

func (g *Guild) MarshalJSON() ([]byte, error)

MarshalJSON see interface json.Marshaler TODO: fix copying of mutex lock

func (*Guild) Member

func (g *Guild) Member(id Snowflake) (*Member, error)

Member return a member by his/her userid

func (*Guild) MembersByName

func (g *Guild) MembersByName(name string) (members []*Member)

MembersByName retrieve a slice of members with same username or nickname

func (*Guild) Reset

func (g *Guild) Reset()

func (*Guild) Role

func (g *Guild) Role(id Snowflake) (role *Role, err error)

Role retrieve a role based on role id

func (*Guild) RoleByName

func (g *Guild) RoleByName(name string) ([]*Role, error)

RoleByName retrieves a slice of roles with same name

func (*Guild) String

func (g *Guild) String() string

type GuildBanAdd

type GuildBanAdd struct {
	GuildID Snowflake       `json:"guild_id"`
	User    *User           `json:"user"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildBanAdd user was banned from a guild

type GuildBanAddHandler

type GuildBanAddHandler = func(s Session, h *GuildBanAdd)

GuildBanAddHandler is triggered in GuildBanAdd events

type GuildBanRemove

type GuildBanRemove struct {
	GuildID Snowflake       `json:"guild_id"`
	User    *User           `json:"user"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildBanRemove user was unbanned from a guild

type GuildBanRemoveHandler

type GuildBanRemoveHandler = func(s Session, h *GuildBanRemove)

GuildBanRemoveHandler is triggered in GuildBanRemove events

type GuildCreate

type GuildCreate struct {
	Guild   *Guild          `json:"guild"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildCreate This event can be sent in three different scenarios:

 1. When a user is initially connecting, to lazily load and backfill information for all unavailable Guilds
    sent in the Ready event.
	2. When a Guild becomes available again to the Client.
	3. When the current user joins a new Guild.

func (*GuildCreate) UnmarshalJSON

func (obj *GuildCreate) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type GuildCreateHandler

type GuildCreateHandler = func(s Session, h *GuildCreate)

GuildCreateHandler is triggered in GuildCreate events

type GuildDelete

type GuildDelete struct {
	UnavailableGuild *GuildUnavailable `json:"guild_unavailable"`
	Ctx              context.Context   `json:"-"`
	ShardID          uint              `json:"-"`
}

GuildDelete guild became unavailable, or user left/was removed from a guild

func (*GuildDelete) UnmarshalJSON

func (obj *GuildDelete) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

func (*GuildDelete) UserWasRemoved

func (obj *GuildDelete) UserWasRemoved() bool

UserWasRemoved ... TODO

type GuildDeleteHandler

type GuildDeleteHandler = func(s Session, h *GuildDelete)

GuildDeleteHandler is triggered in GuildDelete events

type GuildEmbed

type GuildEmbed struct {
	Lockable `json:"-"`

	Enabled   bool      `json:"enabled"`
	ChannelID Snowflake `json:"channel_id"`
}

GuildEmbed https://discordapp.com/developers/docs/resources/guild#guild-embed-object

func (*GuildEmbed) CopyOverTo

func (e *GuildEmbed) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*GuildEmbed) DeepCopy

func (e *GuildEmbed) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type GuildEmojisUpdate

type GuildEmojisUpdate struct {
	GuildID Snowflake       `json:"guild_id"`
	Emojis  []*Emoji        `json:"emojis"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildEmojisUpdate guild emojis were updated

type GuildEmojisUpdateHandler

type GuildEmojisUpdateHandler = func(s Session, h *GuildEmojisUpdate)

GuildEmojisUpdateHandler is triggered in GuildEmojisUpdate events

type GuildIntegrationsUpdate

type GuildIntegrationsUpdate struct {
	GuildID Snowflake       `json:"guild_id"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildIntegrationsUpdate guild integration was updated

type GuildIntegrationsUpdateHandler

type GuildIntegrationsUpdateHandler = func(s Session, h *GuildIntegrationsUpdate)

GuildIntegrationsUpdateHandler is triggered in GuildIntegrationsUpdate events

type GuildMemberAdd

type GuildMemberAdd struct {
	Member  *Member         `json:"member"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildMemberAdd new user joined a guild

func (*GuildMemberAdd) UnmarshalJSON

func (obj *GuildMemberAdd) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type GuildMemberAddHandler

type GuildMemberAddHandler = func(s Session, h *GuildMemberAdd)

GuildMemberAddHandler is triggered in GuildMemberAdd events

type GuildMemberRemove

type GuildMemberRemove struct {
	GuildID Snowflake       `json:"guild_id"`
	User    *User           `json:"user"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildMemberRemove user was removed from a guild

type GuildMemberRemoveHandler

type GuildMemberRemoveHandler = func(s Session, h *GuildMemberRemove)

GuildMemberRemoveHandler is triggered in GuildMemberRemove events

type GuildMemberUpdate

type GuildMemberUpdate struct {
	GuildID Snowflake       `json:"guild_id"`
	Roles   []Snowflake     `json:"roles"`
	User    *User           `json:"user"`
	Nick    string          `json:"nick"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildMemberUpdate guild member was updated

type GuildMemberUpdateHandler

type GuildMemberUpdateHandler = func(s Session, h *GuildMemberUpdate)

GuildMemberUpdateHandler is triggered in GuildMemberUpdate events

type GuildMembersChunk

type GuildMembersChunk struct {
	GuildID Snowflake       `json:"guild_id"`
	Members []*Member       `json:"members"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildMembersChunk response to Request Guild Members

type GuildMembersChunkHandler

type GuildMembersChunkHandler = func(s Session, h *GuildMembersChunk)

GuildMembersChunkHandler is triggered in GuildMembersChunk events

type GuildRoleCreate

type GuildRoleCreate struct {
	GuildID Snowflake       `json:"guild_id"`
	Role    *Role           `json:"role"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildRoleCreate guild role was created

type GuildRoleCreateHandler

type GuildRoleCreateHandler = func(s Session, h *GuildRoleCreate)

GuildRoleCreateHandler is triggered in GuildRoleCreate events

type GuildRoleDelete

type GuildRoleDelete struct {
	GuildID Snowflake       `json:"guild_id"`
	RoleID  Snowflake       `json:"role_id"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildRoleDelete a guild role was deleted

type GuildRoleDeleteHandler

type GuildRoleDeleteHandler = func(s Session, h *GuildRoleDelete)

GuildRoleDeleteHandler is triggered in GuildRoleDelete events

type GuildRoleUpdate

type GuildRoleUpdate struct {
	GuildID Snowflake       `json:"guild_id"`
	Role    *Role           `json:"role"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildRoleUpdate guild role was updated

type GuildRoleUpdateHandler

type GuildRoleUpdateHandler = func(s Session, h *GuildRoleUpdate)

GuildRoleUpdateHandler is triggered in GuildRoleUpdate events

type GuildUnavailable

type GuildUnavailable struct {
	ID          Snowflake `json:"id"`
	Unavailable bool      `json:"unavailable"` // ?*|
	Lockable    `json:"-"`
}

GuildUnavailable is a partial Guild object.

func NewGuildUnavailable

func NewGuildUnavailable(ID Snowflake) *GuildUnavailable

NewGuildUnavailable ...

type GuildUpdate

type GuildUpdate struct {
	Guild   *Guild          `json:"guild"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

GuildUpdate guild was updated

func (*GuildUpdate) UnmarshalJSON

func (obj *GuildUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type GuildUpdateHandler

type GuildUpdateHandler = func(s Session, h *GuildUpdate)

GuildUpdateHandler is triggered in GuildUpdate events

type Handler

type Handler = interface{}

Handler needs to match one of the *Handler signatures

type HandlerChannelCreate

type HandlerChannelCreate = func(Session, *ChannelCreate)

type HandlerChannelDelete

type HandlerChannelDelete = func(Session, *ChannelDelete)

type HandlerChannelPinsUpdate

type HandlerChannelPinsUpdate = func(Session, *ChannelPinsUpdate)

type HandlerChannelUpdate

type HandlerChannelUpdate = func(Session, *ChannelUpdate)

type HandlerCtrl

type HandlerCtrl interface {
	OnInsert(Session) error
	OnRemove(Session) error

	// IsDead does not need to be locked as the demultiplexer access it synchronously.
	IsDead() bool

	// Update For every time Update is called, it's internal trackers must be updated.
	// you should assume that .Update() means the handler was used.
	Update()
}

HandlerCtrl used when inserting a handler to dictate whether or not the handler(s) should still be kept in the handlers list..

type HandlerGuildBanAdd

type HandlerGuildBanAdd = func(Session, *GuildBanAdd)

type HandlerGuildBanRemove

type HandlerGuildBanRemove = func(Session, *GuildBanRemove)

type HandlerGuildCreate

type HandlerGuildCreate = func(Session, *GuildCreate)

type HandlerGuildDelete

type HandlerGuildDelete = func(Session, *GuildDelete)

type HandlerGuildEmojisUpdate

type HandlerGuildEmojisUpdate = func(Session, *GuildEmojisUpdate)

type HandlerGuildIntegrationsUpdate

type HandlerGuildIntegrationsUpdate = func(Session, *GuildIntegrationsUpdate)

type HandlerGuildMemberAdd

type HandlerGuildMemberAdd = func(Session, *GuildMemberAdd)

type HandlerGuildMemberRemove

type HandlerGuildMemberRemove = func(Session, *GuildMemberRemove)

type HandlerGuildMemberUpdate

type HandlerGuildMemberUpdate = func(Session, *GuildMemberUpdate)

type HandlerGuildMembersChunk

type HandlerGuildMembersChunk = func(Session, *GuildMembersChunk)

type HandlerGuildRoleCreate

type HandlerGuildRoleCreate = func(Session, *GuildRoleCreate)

type HandlerGuildRoleDelete

type HandlerGuildRoleDelete = func(Session, *GuildRoleDelete)

type HandlerGuildRoleUpdate

type HandlerGuildRoleUpdate = func(Session, *GuildRoleUpdate)

type HandlerGuildUpdate

type HandlerGuildUpdate = func(Session, *GuildUpdate)

type HandlerMessageCreate

type HandlerMessageCreate = func(Session, *MessageCreate)

type HandlerMessageDelete

type HandlerMessageDelete = func(Session, *MessageDelete)

type HandlerMessageDeleteBulk

type HandlerMessageDeleteBulk = func(Session, *MessageDeleteBulk)

type HandlerMessageReactionAdd

type HandlerMessageReactionAdd = func(Session, *MessageReactionAdd)

type HandlerMessageReactionRemove

type HandlerMessageReactionRemove = func(Session, *MessageReactionRemove)

type HandlerMessageReactionRemoveAll

type HandlerMessageReactionRemoveAll = func(Session, *MessageReactionRemoveAll)

type HandlerMessageUpdate

type HandlerMessageUpdate = func(Session, *MessageUpdate)

type HandlerPresenceUpdate

type HandlerPresenceUpdate = func(Session, *PresenceUpdate)

type HandlerReady

type HandlerReady = func(Session, *Ready)

type HandlerResumed

type HandlerResumed = func(Session, *Resumed)

type HandlerSpecErr

type HandlerSpecErr = disgorderr.HandlerSpecErr

type HandlerTypingStart

type HandlerTypingStart = func(Session, *TypingStart)

type HandlerUserUpdate

type HandlerUserUpdate = func(Session, *UserUpdate)

type HandlerVoiceServerUpdate

type HandlerVoiceServerUpdate = func(Session, *VoiceServerUpdate)

type HandlerVoiceStateUpdate

type HandlerVoiceStateUpdate = func(Session, *VoiceStateUpdate)

type HandlerWebhooksUpdate

type HandlerWebhooksUpdate = func(Session, *WebhooksUpdate)

type Integration

type Integration struct {
	Lockable `json:"-"`

	ID                Snowflake           `json:"id"`
	Name              string              `json:"name"`
	Type              string              `json:"type"`
	Enabled           bool                `json:"enabled"`
	Syncing           bool                `json:"syncing"`
	RoleID            Snowflake           `json:"role_id"`
	ExpireBehavior    int                 `json:"expire_behavior"`
	ExpireGracePeriod int                 `json:"expire_grace_period"`
	User              *User               `json:"user"`
	Account           *IntegrationAccount `json:"account"`
}

Integration https://discordapp.com/developers/docs/resources/guild#integration-object

func (*Integration) CopyOverTo

func (i *Integration) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Integration) DeepCopy

func (i *Integration) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type IntegrationAccount

type IntegrationAccount struct {
	Lockable `json:"-"`

	ID   string `json:"id"`   // id of the account
	Name string `json:"name"` // name of the account
}

IntegrationAccount https://discordapp.com/developers/docs/resources/guild#integration-account-object

func (*IntegrationAccount) CopyOverTo

func (i *IntegrationAccount) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*IntegrationAccount) DeepCopy

func (i *IntegrationAccount) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type Invite

type Invite struct {
	Lockable `json:"-"`

	// Code the invite code (unique Snowflake)
	Code string `json:"code"`

	// Guild the guild this invite is for
	Guild *PartialGuild `json:"guild"`

	// Channel the channel this invite is for
	Channel *PartialChannel `json:"channel"`

	// ApproximatePresenceCount approximate count of online members
	ApproximatePresenceCount int `json:"approximate_presence_count,omitempty"`

	// ApproximatePresenceCount approximate count of total members
	ApproximateMemberCount int `json:"approximate_member_count,omitempty"`
}

Invite Represents a code that when used, adds a user to a guild. https://discordapp.com/developers/docs/resources/invite#invite-object Reviewed: 2018-06-10

func (*Invite) CopyOverTo

func (i *Invite) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Invite) DeepCopy

func (i *Invite) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type InviteMetadata

type InviteMetadata struct {
	Lockable `json:"-"`

	// Inviter user who created the invite
	Inviter *User `json:"inviter"`

	// Uses number of times this invite has been used
	Uses int `json:"uses"`

	// MaxUses max number of times this invite can be used
	MaxUses int `json:"max_uses"`

	// MaxAge duration (in seconds) after which the invite expires
	MaxAge int `json:"max_age"`

	// Temporary whether this invite only grants temporary membership
	Temporary bool `json:"temporary"`

	// CreatedAt when this invite was created
	CreatedAt Time `json:"created_at"`

	// Revoked whether this invite is revoked
	Revoked bool `json:"revoked"`
}

InviteMetadata Object https://discordapp.com/developers/docs/resources/invite#invite-metadata-object Reviewed: 2018-06-10

func (*InviteMetadata) CopyOverTo

func (i *InviteMetadata) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*InviteMetadata) DeepCopy

func (i *InviteMetadata) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

type Link interface {
	// Connect establishes a websocket connection to the discord API
	Connect(ctx context.Context) error

	// Disconnect closes the discord websocket connection
	Disconnect() error
}

Link allows basic Discord connection control. Affects all shards

type Lockable

type Lockable struct {
	sync.RWMutex
}

type Logger

type Logger = logger.Logger

Logger super basic logging interface

type MFALvl

type MFALvl uint

MFALvl ... https://discordapp.com/developers/docs/resources/guild#guild-object-mfa-level

const (
	MFALvlNone MFALvl = iota
	MFALvlElevated
)

Different MFA levels

func (*MFALvl) Elevated

func (mfal *MFALvl) Elevated() bool

Elevated ...

func (*MFALvl) None

func (mfal *MFALvl) None() bool

None ...

type Member

type Member struct {
	Lockable `json:"-"`

	GuildID  Snowflake   `json:"guild_id,omitempty"`
	User     *User       `json:"user"`
	Nick     string      `json:"nick,omitempty"` // ?|
	Roles    []Snowflake `json:"roles"`
	JoinedAt Time        `json:"joined_at,omitempty"`

	// voice
	Deaf bool `json:"deaf"`
	Mute bool `json:"mute"`
	// contains filtered or unexported fields
}

Member https://discordapp.com/developers/docs/resources/guild#guild-member-object

func (*Member) CopyOverTo

func (m *Member) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Member) DeepCopy

func (m *Member) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*Member) GetPermissions

func (m *Member) GetPermissions(ctx context.Context, s Session) (p uint64, err error)

func (*Member) GetUser

func (m *Member) GetUser(ctx context.Context, session Session) (usr *User, err error)

GetUser tries to ensure that you get a user object and not a nil. The user can be nil if the guild was fetched from the Cache.

func (*Member) Mention

func (m *Member) Mention() string

Mention creates a string which is parsed into a member mention on Discord GUI's

func (*Member) Reset

func (m *Member) Reset()

func (*Member) String

func (m *Member) String() string

func (*Member) UpdateNick

func (m *Member) UpdateNick(ctx context.Context, client nickUpdater, nickname string, flags ...Flag) error

type MentionChannel

type MentionChannel struct {
	ID      Snowflake `json:"id"`
	GuildID Snowflake `json:"guild_id"`
	Type    int       `json:"type"`
	Name    string    `json:"name"`
}

type Mentioner

type Mentioner interface {
	Mention() string
}

Mentioner can be implemented by any type that is mentionable. https://discordapp.com/developers/docs/reference#message-formatting-formats

type Message

type Message struct {
	Lockable         `json:"-"`
	ID               Snowflake          `json:"id"`
	ChannelID        Snowflake          `json:"channel_id"`
	Author           *User              `json:"author"`
	Member           *Member            `json:"member"`
	Content          string             `json:"content"`
	Timestamp        Time               `json:"timestamp"`
	EditedTimestamp  Time               `json:"edited_timestamp"` // ?
	Tts              bool               `json:"tts"`
	MentionEveryone  bool               `json:"mention_everyone"`
	Mentions         []*User            `json:"mentions"`
	MentionRoles     []Snowflake        `json:"mention_roles"`
	MentionChannels  []*MentionChannel  `json:"mention_channels"`
	Attachments      []*Attachment      `json:"attachments"`
	Embeds           []*Embed           `json:"embeds"`
	Reactions        []*Reaction        `json:"reactions"` // ?
	Nonce            interface{}        `json:"nonce"`     // NOT A SNOWFLAKE! DONT TOUCH!
	Pinned           bool               `json:"pinned"`
	WebhookID        Snowflake          `json:"webhook_id"` // ?
	Type             MessageType        `json:"type"`
	Activity         MessageActivity    `json:"activity"`
	Application      MessageApplication `json:"application"`
	MessageReference *MessageReference  `json:"message_reference"`
	Flags            MessageFlag        `json:"flags"`

	// GuildID is not set when using a REST request. Only socket events.
	GuildID Snowflake `json:"guild_id"`

	// SpoilerTagContent is only true if the entire message text is tagged as a spoiler (aka completely wrapped in ||)
	SpoilerTagContent        bool `json:"-"`
	SpoilerTagAllAttachments bool `json:"-"`
	HasSpoilerImage          bool `json:"-"`
}

Message https://discordapp.com/developers/docs/resources/channel#message-object-message-structure

func NewMessage

func NewMessage() *Message

NewMessage ...

func (*Message) CopyOverTo

func (m *Message) CopyOverTo(other interface{}) (err error)

CopyOverTo see interface at struct.go#Copier

func (*Message) DeepCopy

func (m *Message) DeepCopy() (copy interface{})

DeepCopy see interface at struct.go#DeepCopier

func (*Message) DiscordURL

func (m *Message) DiscordURL() (string, error)

DiscordURL returns the Discord link to the message. This can be used to jump directly to a message from within the client.

Example: https://discordapp.com/channels/319567980491046913/644376487331495967/646925626523254795

func (*Message) IsDirectMessage

func (m *Message) IsDirectMessage() bool

IsDirectMessage checks if the message is from a direct message channel.

WARNING! Note that, when fetching messages using the REST API the guildID might be empty -> giving a false positive.

func (*Message) React

func (m *Message) React(ctx context.Context, s Session, emoji interface{}, flags ...Flag) error

func (*Message) Reply

func (m *Message) Reply(ctx context.Context, client msgSender, data ...interface{}) (*Message, error)

Reply input any type as an reply. int, string, an object, etc.

func (*Message) Reset

func (m *Message) Reset()

func (*Message) Send

func (m *Message) Send(ctx context.Context, client MessageSender, flags ...Flag) (msg *Message, err error)

Send sends this message to discord.

func (*Message) String

func (m *Message) String() string

func (*Message) Unreact

func (m *Message) Unreact(ctx context.Context, s Session, emoji interface{}, flags ...Flag) error

type MessageActivity

type MessageActivity struct {
	Type    int    `json:"type"`
	PartyID string `json:"party_id"`
}

MessageActivity https://discordapp.com/developers/docs/resources/channel#message-object-message-activity-structure

type MessageApplication

type MessageApplication struct {
	ID          Snowflake `json:"id"`
	CoverImage  string    `json:"cover_image"`
	Description string    `json:"description"`
	Icon        string    `json:"icon"`
	Name        string    `json:"name"`
}

MessageApplication https://discordapp.com/developers/docs/resources/channel#message-object-message-application-structure

type MessageCreate

type MessageCreate struct {
	Message *Message
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

MessageCreate message was created

func (*MessageCreate) Reset

func (m *MessageCreate) Reset()

func (*MessageCreate) UnmarshalJSON

func (obj *MessageCreate) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type MessageCreateHandler

type MessageCreateHandler = func(s Session, h *MessageCreate)

MessageCreateHandler is triggered in MessageCreate events

type MessageDelete

type MessageDelete struct {
	MessageID Snowflake       `json:"id"`
	ChannelID Snowflake       `json:"channel_id"`
	GuildID   Snowflake       `json:"guild_id,omitempty"`
	Ctx       context.Context `json:"-"`
	ShardID   uint            `json:"-"`
}

MessageDelete message was deleted

type MessageDeleteBulk

type MessageDeleteBulk struct {
	MessageIDs []Snowflake     `json:"ids"`
	ChannelID  Snowflake       `json:"channel_id"`
	Ctx        context.Context `json:"-"`
	ShardID    uint            `json:"-"`
}

MessageDeleteBulk multiple messages were deleted at once

type MessageDeleteBulkHandler

type MessageDeleteBulkHandler = func(s Session, h *MessageDeleteBulk)

MessageDeleteBulkHandler is triggered in MessageDeleteBulk events

type MessageDeleteHandler

type MessageDeleteHandler = func(s Session, h *MessageDelete)

MessageDeleteHandler is triggered in MessageDelete events

type MessageFlag

type MessageFlag uint
const (
	// MessageFlagCrossposted this message has been published to subscribed Channels (via Channel Following)
	MessageFlagCrossposted MessageFlag = 1 << iota

	// MessageFlagIsCrosspost this message originated from a message in another channel (via Channel Following)
	MessageFlagIsCrosspost

	// MessageFlagSupressEmbeds do not include any embeds when serializing this message
	MessageFlagSupressEmbeds
)

type MessageReactionAdd

type MessageReactionAdd struct {
	UserID    Snowflake `json:"user_id"`
	ChannelID Snowflake `json:"channel_id"`
	MessageID Snowflake `json:"message_id"`
	// PartialEmoji id and name. id might be nil
	PartialEmoji *Emoji          `json:"emoji"`
	Ctx          context.Context `json:"-"`
	ShardID      uint            `json:"-"`
}

MessageReactionAdd user reacted to a message Note! do not Cache emoji, unless it's updated with guildID TODO: find guildID when given userID, ChannelID and MessageID

type MessageReactionAddHandler

type MessageReactionAddHandler = func(s Session, h *MessageReactionAdd)

MessageReactionAddHandler is triggered in MessageReactionAdd events

type MessageReactionRemove

type MessageReactionRemove struct {
	UserID    Snowflake `json:"user_id"`
	ChannelID Snowflake `json:"channel_id"`
	MessageID Snowflake `json:"message_id"`
	// PartialEmoji id and name. id might be nil
	PartialEmoji *Emoji          `json:"emoji"`
	Ctx          context.Context `json:"-"`
	ShardID      uint            `json:"-"`
}

MessageReactionRemove user removed a reaction from a message Note! do not Cache emoji, unless it's updated with guildID TODO: find guildID when given userID, ChannelID and MessageID

type MessageReactionRemoveAll

type MessageReactionRemoveAll struct {
	ChannelID Snowflake       `json:"channel_id"`
	MessageID Snowflake       `json:"message_id"`
	Ctx       context.Context `json:"-"`
	ShardID   uint            `json:"-"`
}

MessageReactionRemoveAll all reactions were explicitly removed from a message

type MessageReactionRemoveAllHandler

type MessageReactionRemoveAllHandler = func(s Session, h *MessageReactionRemoveAll)

MessageReactionRemoveAllHandler is triggered in MessageReactionRemoveAll events

type MessageReactionRemoveHandler

type MessageReactionRemoveHandler = func(s Session, h *MessageReactionRemove)

MessageReactionRemoveHandler is triggered in MessageReactionRemove events

type MessageReference

type MessageReference struct {
	MessageID Snowflake `json:"message_id"`
	ChannelID Snowflake `json:"channel_id"`
	GuildID   Snowflake `json:"guild_id"`
}

type MessageSender

type MessageSender interface {
	CreateMessage(ctx context.Context, channelID Snowflake, params *CreateMessageParams, flags ...Flag) (ret *Message, err error)
}

MessageSender is an interface which only holds the method needed for creating a channel message

type MessageType

type MessageType uint // TODO: once auto generated, un-export this.

The different message types usually generated by Discord. eg. "a new user joined"

const (
	MessageTypeDefault MessageType = iota
	MessageTypeRecipientAdd
	MessageTypeRecipientRemove
	MessageTypeCall
	MessageTypeChannelNameChange
	MessageTypeChannelIconChange
	MessageTypeChannelPinnedMessage
	MessageTypeGuildMemberJoin
	MessageTypeUserPremiumGuildSubscription
	MessageTypeUserPremiumGuildSubscriptionTier1
	MessageTypeUserPremiumGuildSubscriptionTier2
	MessageTypeUserPremiumGuildSubscriptionTier3
	MessageTypeChannelFollowAdd
)

type MessageUpdate

type MessageUpdate struct {
	Message *Message
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

MessageUpdate message was edited

func (*MessageUpdate) UnmarshalJSON

func (obj *MessageUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON ...

type MessageUpdateHandler

type MessageUpdateHandler = func(s Session, h *MessageUpdate)

MessageUpdateHandler is triggered in MessageUpdate events

type MessageUpdater

type MessageUpdater interface {
	UpdateMessage(ctx context.Context, chanID, msgID Snowflake, flags ...Flag) *updateMessageBuilder
}

MessageUpdater is a interface which only holds the message update method

type Middleware

type Middleware = func(interface{}) interface{}

Middleware allows you to manipulate data during the "stream"

type PartialBan

type PartialBan struct {
	Reason                 string
	BannedUserID           Snowflake
	ModeratorResponsibleID Snowflake
}

PartialBan is used by audit logs

func (*PartialBan) String

func (p *PartialBan) String() string

type PartialChannel

type PartialChannel struct {
	Lockable `json:"-"`
	ID       Snowflake `json:"id"`
	Name     string    `json:"name"`
	Type     uint      `json:"type"`
}

PartialChannel ... example of partial channel // "channel": { // "id": "165176875973476352", // "name": "illuminati", // "type": 0 // }

type PartialEmoji

type PartialEmoji = Emoji

PartialEmoji see Emoji

type PartialGuild

type PartialGuild = Guild // TODO: find the actual data struct for partial guild

PartialGuild see Guild

type PartialInvite

type PartialInvite = Invite

PartialInvite ... {

"code": "abc"

}

type PermissionBit

type PermissionBit = uint64
const (
	PermissionReadMessages PermissionBit = 1 << (iota + 10)
	PermissionSendMessages
	PermissionSendTTSMessages
	PermissionManageMessages
	PermissionEmbedLinks
	PermissionAttachFiles
	PermissionReadMessageHistory
	PermissionMentionEveryone
	PermissionUseExternalEmojis
)

Constants for the different bit offsets of text channel permissions

const (
	PermissionVoiceConnect PermissionBit = 1 << (iota + 20)
	PermissionVoiceSpeak
	PermissionVoiceMuteMembers
	PermissionVoiceDeafenMembers
	PermissionVoiceMoveMembers
	PermissionVoiceUseVAD
	PermissionVoicePrioritySpeaker PermissionBit = 1 << (iota + 2)
)

Constants for the different bit offsets of voice permissions

const (
	PermissionChangeNickname PermissionBit = 1 << (iota + 26)
	PermissionManageNicknames
	PermissionManageRoles
	PermissionManageWebhooks
	PermissionManageEmojis
)

Constants for general management.

type PermissionBits

type PermissionBits = PermissionBit

type PermissionOverwrite

type PermissionOverwrite struct {
	ID    Snowflake      `json:"id"`    // role or user id
	Type  string         `json:"type"`  // either `role` or `member`
	Allow PermissionBits `json:"allow"` // permission bit set
	Deny  PermissionBits `json:"deny"`  // permission bit set
}

PermissionOverwrite https://discordapp.com/developers/docs/resources/channel#overwrite-object

type Pool

type Pool interface {
	Put(x Reseter)
	Get() (x Reseter)
}

type PremiumType

type PremiumType int
const (
	// PremiumTypeNitroClassic includes app perks like animated emojis and avatars, but not games
	PremiumTypeNitroClassic PremiumType = 1

	// PremiumTypeNitro includes app perks as well as the games subscription service
	PremiumTypeNitro PremiumType = 2
)

func (PremiumType) String

func (p PremiumType) String() (t string)

type PresenceUpdate

type PresenceUpdate struct {
	User    *User       `json:"user"`
	RoleIDs []Snowflake `json:"roles"`
	Game    *Activity   `json:"game"`
	GuildID Snowflake   `json:"guild_id"`

	// Status either "idle", "dnd", "online", or "offline"
	// TODO: constants somewhere..
	Status  string          `json:"status"`
	Ctx     context.Context `json:"-"`
	ShardID uint            `json:"-"`
}

PresenceUpdate user's presence was updated in a guild

type PresenceUpdateHandler

type PresenceUpdateHandler = func(s Session, h *PresenceUpdate)

PresenceUpdateHandler is triggered in PresenceUpdate events

type RESTAuditLogs

type RESTAuditLogs interface {
	// GetGuildAuditLogs Returns an audit log object for the guild. Requires the 'VIEW_AUDIT_LOG' permission.
	// Note that this request will _always_ send a REST request, regardless of you calling IgnoreCache or not.
	GetGuildAuditLogs(ctx context.Context, guildID Snowflake, flags ...Flag) *guildAuditLogsBuilder
}

AuditLogsRESTer REST interface for all audit-logs endpoints

type RESTBuilder

type RESTBuilder struct {
	// contains filtered or unexported fields
}

func (*RESTBuilder) CancelOnRatelimit

func (b *RESTBuilder) CancelOnRatelimit() *RESTBuilder

func (*RESTBuilder) IgnoreCache

func (b *RESTBuilder) IgnoreCache() *RESTBuilder

type RESTChannel

type RESTChannel interface {
	RESTMessage
	RESTReaction

	// TriggerTypingIndicator Post a typing indicator for the specified channel. Generally bots should not implement
	// this route. However, if a bot is responding to a command and expects the computation to take a few seconds, this
	// endpoint may be called to let the user know that the bot is processing their message. Returns a 204 empty response
	// on success. Fires a Typing Start Gateway event.
	TriggerTypingIndicator(ctx context.Context, channelID Snowflake, flags ...Flag) (err error)

	// GetPinnedMessages Returns all pinned messages in the channel as an array of message objects.
	GetPinnedMessages(ctx context.Context, channelID Snowflake, flags ...Flag) (ret []*Message, err error)

	// PinMessage same as PinMessageID
	PinMessage(ctx context.Context, msg *Message, flags ...Flag) (err error)

	// PinMessageID Pin a message by its ID and channel ID. Requires the 'MANAGE_MESSAGES' permission.
	// Returns a 204 empty response on success.
	PinMessageID(ctx context.Context, channelID, msgID Snowflake, flags ...Flag) (err error)

	// UnpinMessage same as UnpinMessageID
	UnpinMessage(ctx context.Context, msg *Message, flags ...Flag) (err error)

	// UnpinMessageID Delete a pinned message in a channel. Requires the 'MANAGE_MESSAGES' permission.
	// Returns a 204 empty response on success. Returns a 204 empty response on success.
	UnpinMessageID(ctx context.Context, channelID, msgID Snowflake, flags ...Flag) (err error)

	// GetChannel Get a channel by Snowflake. Returns a channel object.
	GetChannel(ctx context.Context, id Snowflake, flags ...Flag) (ret *Channel, err error)

	// UpdateChannel Update a Channels settings. Requires the 'MANAGE_CHANNELS' permission for the guild. Returns
	// a channel on success, and a 400 BAD REQUEST on invalid parameters. Fires a Channel Update Gateway event. If
	// modifying a category, individual Channel Update events will fire for each child channel that also changes.
	// For the PATCH method, all the JSON Params are optional.
	UpdateChannel(ctx context.Context, id Snowflake, flags ...Flag) (builder *updateChannelBuilder)

	// DeleteChannel Delete a channel, or close a private message. Requires the 'MANAGE_CHANNELS' permission for
	// the guild. Deleting a category does not delete its child Channels; they will have their parent_id removed and a
	// Channel Update Gateway event will fire for each of them. Returns a channel object on success.
	// Fires a Channel Delete Gateway event.
	DeleteChannel(ctx context.Context, id Snowflake, flags ...Flag) (channel *Channel, err error)

	// EditChannelPermissions Edit the channel permission overwrites for a user or role in a channel. Only usable
	// for guild Channels. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success.
	// For more information about permissions, see permissions.
	UpdateChannelPermissions(ctx context.Context, chanID, overwriteID Snowflake, params *UpdateChannelPermissionsParams, flags ...Flag) (err error)

	// GetChannelInvites Returns a list of invite objects (with invite metadata) for the channel. Only usable for
	// guild Channels. Requires the 'MANAGE_CHANNELS' permission.
	GetChannelInvites(ctx context.Context, id Snowflake, flags ...Flag) (ret []*Invite, err error)

	// CreateChannelInvites Create a new invite object for the channel. Only usable for guild Channels. Requires
	// the CREATE_INSTANT_INVITE permission. All JSON parameters for this route are optional, however the request
	// body is not. If you are not sending any fields, you still have to send an empty JSON object ({}).
	// Returns an invite object.
	CreateChannelInvites(ctx context.Context, id Snowflake, params *CreateChannelInvitesParams, flags ...Flag) (ret *Invite, err error)

	// DeleteChannelPermission Delete a channel permission overwrite for a user or role in a channel. Only usable
	// for guild Channels. Requires the 'MANAGE_ROLES' permission. Returns a 204 empty response on success. For more
	// information about permissions,
	// see permissions: https://discordapp.com/developers/docs/topics/permissions#permissions
	DeleteChannelPermission(ctx context.Context, channelID, overwriteID Snowflake, flags ...Flag) (err error)

	// AddDMParticipant Adds a recipient to a Group DM using their access token. Returns a 204 empty response
	// on success.
	AddDMParticipant(ctx context.Context, channelID Snowflake, participant *GroupDMParticipant, flags ...Flag) (err error)

	// KickParticipant Removes a recipient from a Group DM. Returns a 204 empty response on success.
	KickParticipant(ctx context.Context, channelID, userID Snowflake, flags ...Flag) (err error)
}

RESTChannel REST interface for all Channel endpoints

type RESTEmoji

type RESTEmoji interface {
	// GetGuildEmoji Returns an emoji object for the given guild and emoji IDs.
	GetGuildEmoji(ctx context.Context, guildID, emojiID Snowflake, flags ...Flag) (*Emoji, error)

	// GetGuildEmojis Returns a list of emoji objects for the given guild.
	GetGuildEmojis(ctx context.Context, id Snowflake, flags ...Flag) ([]*Emoji, error)

	// CreateGuildEmoji Create a new emoji for the guild. Requires the 'MANAGE_EMOJIS' permission.
	// Returns the new emoji object on success. Fires a Guild Emojis Update Gateway event.
	CreateGuildEmoji(ctx context.Context, guildID Snowflake, params *CreateGuildEmojiParams, flags ...Flag) (*Emoji, error)

	// UpdateGuildEmoji Modify the given emoji. Requires the 'MANAGE_EMOJIS' permission.
	// Returns the updated emoji object on success. Fires a Guild Emojis Update Gateway event.
	UpdateGuildEmoji(ctx context.Context, guildID, emojiID Snowflake, flags ...Flag) *updateGuildEmojiBuilder

	// DeleteGuildEmoji Delete the given emoji. Requires the 'MANAGE_EMOJIS' permission. Returns 204 No Content on
	// success. Fires a Guild Emojis Update Gateway event.
	DeleteGuildEmoji(ctx context.Context, guildID, emojiID Snowflake, flags ...Flag) error
}

RESTEmoji REST interface for all emoji endpoints

type RESTGuild

type RESTGuild interface {
	// CreateGuild Create a new guild. Returns a guild object on success. Fires a Guild Create Gateway event.
	CreateGuild(ctx context.Context, guildName string, params *CreateGuildParams, flags ...Flag) (*Guild, error)

	// GetGuild Returns the guild object for the given id.
	GetGuild(ctx context.Context, id Snowflake, flags ...Flag) (*Guild, error)

	// ModifyGuild Modify a guild's settings. Requires the 'MANAGE_GUILD' permission. Returns the updated guild
	// object on success. Fires a Guild Update Gateway event.
	UpdateGuild(ctx context.Context, id Snowflake, flags ...Flag) *updateGuildBuilder

	// DeleteGuild Delete a guild permanently. User must be owner. Returns 204 No Content on success.
	// Fires a Guild Delete Gateway event.
	DeleteGuild(ctx context.Context, id Snowflake, flags ...Flag) error

	// GetGuildChannels Returns a list of guild channel objects.
	GetGuildChannels(ctx context.Context, id Snowflake, flags ...Flag) ([]*Channel, error)

	// CreateGuildChannel Create a new channel object for the guild. Requires the 'MANAGE_CHANNELS' permission.
	// Returns the new channel object on success. Fires a Channel Create Gateway event.
	CreateGuildChannel(ctx context.Context, id Snowflake, name string, params *CreateGuildChannelParams, flags ...Flag) (*Channel, error)

	// UpdateGuildChannelPositions Modify the positions of a set of channel objects for the guild.
	// Requires 'MANAGE_CHANNELS' permission. Returns a 204 empty response on success. Fires multiple Channel Update
	// Gateway events.
	UpdateGuildChannelPositions(ctx context.Context, id Snowflake, params []UpdateGuildChannelPositionsParams, flags ...Flag) error

	// GetMember Returns a guild member object for the specified user.
	GetMember(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (*Member, error)

	// GetMembers uses the GetGuildMembers endpoint iteratively until your query params are met.
	GetMembers(ctx context.Context, guildID Snowflake, params *GetMembersParams, flags ...Flag) ([]*Member, error)

	// AddGuildMember Adds a user to the guild, provided you have a valid oauth2 access token for the user with
	// the Guilds.join scope. Returns a 201 Created with the guild member as the body, or 204 No Content if the user is
	// already a member of the guild. Fires a Guild Member Add Gateway event. Requires the bot to have the
	// CREATE_INSTANT_INVITE permission.
	AddGuildMember(ctx context.Context, guildID, userID Snowflake, accessToken string, params *AddGuildMemberParams, flags ...Flag) (*Member, error)

	// ModifyGuildMember Modify attributes of a guild member. Returns a 204 empty response on success.
	// Fires a Guild Member Update Gateway event.
	UpdateGuildMember(ctx context.Context, guildID, userID Snowflake, flags ...Flag) *updateGuildMemberBuilder

	// SetCurrentUserNick Modifies the nickname of the current user in a guild. Returns a 200
	// with the nickname on success. Fires a Guild Member Update Gateway event.
	SetCurrentUserNick(ctx context.Context, id Snowflake, nick string, flags ...Flag) (newNick string, err error)

	// AddGuildMemberRole Adds a role to a guild member. Requires the 'MANAGE_ROLES' permission.
	// Returns a 204 empty response on success. Fires a Guild Member Update Gateway event.
	AddGuildMemberRole(ctx context.Context, guildID, userID, roleID Snowflake, flags ...Flag) error

	// RemoveGuildMemberRole Removes a role from a guild member. Requires the 'MANAGE_ROLES' permission.
	// Returns a 204 empty response on success. Fires a Guild Member Update Gateway event.
	RemoveGuildMemberRole(ctx context.Context, guildID, userID, roleID Snowflake, flags ...Flag) error

	// RemoveGuildMember Remove a member from a guild. Requires 'KICK_MEMBERS' permission.
	// Returns a 204 empty response on success. Fires a Guild Member Remove Gateway event.
	KickMember(ctx context.Context, guildID, userID Snowflake, reason string, flags ...Flag) error

	// GetGuildBans Returns a list of ban objects for the Users banned from this guild. Requires the 'BAN_MEMBERS' permission.
	GetGuildBans(ctx context.Context, id Snowflake, flags ...Flag) ([]*Ban, error)

	// GetGuildBan Returns a ban object for the given user or a 404 not found if the ban cannot be found.
	// Requires the 'BAN_MEMBERS' permission.
	GetGuildBan(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (*Ban, error)

	// BanMember Create a guild ban, and optionally delete previous messages sent by the banned user. Requires
	// the 'BAN_MEMBERS' permission. Returns a 204 empty response on success. Fires a Guild Ban Add Gateway event.
	BanMember(ctx context.Context, guildID, userID Snowflake, params *BanMemberParams, flags ...Flag) error

	// UnbanMember Remove the ban for a user. Requires the 'BAN_MEMBERS' permissions.
	// Returns a 204 empty response on success. Fires a Guild Ban Remove Gateway event.
	UnbanMember(ctx context.Context, guildID, userID Snowflake, reason string, flags ...Flag) error

	// GetGuildRoles Returns a list of role objects for the guild.
	GetGuildRoles(ctx context.Context, guildID Snowflake, flags ...Flag) ([]*Role, error)

	GetMemberPermissions(ctx context.Context, guildID, userID Snowflake, flags ...Flag) (permissions PermissionBits, err error)

	// CreateGuildRole Create a new role for the guild. Requires the 'MANAGE_ROLES' permission.
	// Returns the new role object on success. Fires a Guild Role Create Gateway event.
	CreateGuildRole(ctx context.Context, id Snowflake, params *CreateGuildRoleParams, flags ...Flag) (*Role, error)

	// UpdateGuildRolePositions Modify the positions of a set of role objects for the guild.
	// Requires the 'MANAGE_ROLES' permission. Returns a list of all of the guild's role objects on success.
	// Fires multiple Guild Role Update Gateway events.
	UpdateGuildRolePositions(ctx context.Context, guildID Snowflake, params []UpdateGuildRolePositionsParams, flags ...Flag) ([]*Role, error)

	// ModifyGuildRole Modify a guild role. Requires the 'MANAGE_ROLES' permission.
	// Returns the updated role on success. Fires a Guild Role Update Gateway event.
	UpdateGuildRole(ctx context.Context, guildID, roleID Snowflake, flags ...Flag) (builder *updateGuildRoleBuilder)

	// DeleteGuildRole Delete a guild role. Requires the 'MANAGE_ROLES' permission.
	// Returns a 204 empty response on success. Fires a Guild Role Delete Gateway event.
	DeleteGuildRole(ctx context.Context, guildID, roleID Snowflake, flags ...Flag) error

	// EstimatePruneMembersCount Returns an object with one 'pruned' key indicating the number of members that would be
	// removed in a prune operation. Requires the 'KICK_MEMBERS' permission.
	EstimatePruneMembersCount(ctx context.Context, id Snowflake, days int, flags ...Flag) (estimate int, err error)

	// PruneMembers Kicks members from N day back. Requires the 'KICK_MEMBERS' permission.
	// The estimate of kicked people is not returned. Use EstimatePruneMembersCount before calling PruneMembers
	// if you need it. Fires multiple Guild Member Remove Gateway events.
	PruneMembers(ctx context.Context, id Snowflake, days int, reason string, flags ...Flag) error

	// GetGuildVoiceRegions Returns a list of voice region objects for the guild. Unlike the similar /voice route,
	// this returns VIP servers when the guild is VIP-enabled.
	GetGuildVoiceRegions(ctx context.Context, id Snowflake, flags ...Flag) ([]*VoiceRegion, error)

	// GetGuildInvites Returns a list of invite objects (with invite metadata) for the guild.
	// Requires the 'MANAGE_GUILD' permission.
	GetGuildInvites(ctx context.Context, id Snowflake, flags ...Flag) ([]*Invite, error)

	// GetGuildIntegrations Returns a list of integration objects for the guild.
	// Requires the 'MANAGE_GUILD' permission.
	GetGuildIntegrations(ctx context.Context, id Snowflake, flags ...Flag) ([]*Integration, error)

	// CreateGuildIntegration Attach an integration object from the current user to the guild.
	// Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success.
	// Fires a Guild Integrations Update Gateway event.
	CreateGuildIntegration(ctx context.Context, guildID Snowflake, params *CreateGuildIntegrationParams, flags ...Flag) error

	// UpdateGuildIntegration Modify the behavior and settings of a integration object for the guild.
	// Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success.
	// Fires a Guild Integrations Update Gateway event.
	UpdateGuildIntegration(ctx context.Context, guildID, integrationID Snowflake, params *UpdateGuildIntegrationParams, flags ...Flag) error

	// DeleteGuildIntegration Delete the attached integration object for the guild.
	// Requires the 'MANAGE_GUILD' permission. Returns a 204 empty response on success.
	// Fires a Guild Integrations Update Gateway event.
	DeleteGuildIntegration(ctx context.Context, guildID, integrationID Snowflake, flags ...Flag) error

	// SyncGuildIntegration Sync an integration. Requires the 'MANAGE_GUILD' permission.
	// Returns a 204 empty response on success.
	SyncGuildIntegration(ctx context.Context, guildID, integrationID Snowflake, flags ...Flag) error

	// GetGuildEmbed Returns the guild embed object. Requires the 'MANAGE_GUILD' permission.
	GetGuildEmbed(ctx context.Context, guildID Snowflake, flags ...Flag) (*GuildEmbed, error)

	// UpdateGuildEmbed Modify a guild embed object for the guild. All attributes may be passed in with JSON and
	// modified. Requires the 'MANAGE_GUILD' permission. Returns the updated guild embed object.
	UpdateGuildEmbed(ctx context.Context, guildID Snowflake, flags ...Flag) *updateGuildEmbedBuilder

	// GetGuildVanityURL Returns a partial invite object for Guilds with that feature enabled.
	// Requires the 'MANAGE_GUILD' permission.
	GetGuildVanityURL(ctx context.Context, guildID Snowflake, flags ...Flag) (*PartialInvite, error)
}

RESTGuild REST interface for all guild endpoints

type RESTInvite

type RESTInvite interface {
	// GetInvite Returns an invite object for the given code.
	GetInvite(ctx context.Context, inviteCode string, params URLQueryStringer, flags ...Flag) (*Invite, error)

	// DeleteInvite Delete an invite. Requires the MANAGE_CHANNELS permission. Returns an invite object on success.
	DeleteInvite(ctx context.Context, inviteCode string, flags ...Flag) (deleted *Invite, err error)
}

RESTInvite REST interface for all invite endpoints

type RESTMessage

type RESTMessage interface {
	// GetMessages Returns the messages for a channel. If operating on a guild channel, this endpoint requires
	// the 'VIEW_CHANNEL' permission to be present on the current user. If the current user is missing
	// the 'READ_MESSAGE_HISTORY' permission in the channel then this will return no messages
	// (since they cannot read the message history). Returns an array of message objects on success.
	GetMessages(ctx context.Context, channelID Snowflake, params *GetMessagesParams, flags ...Flag) ([]*Message, error)

	// GetMessage Returns a specific message in the channel. If operating on a guild channel, this endpoints
	// requires the 'READ_MESSAGE_HISTORY' permission to be present on the current user.
	// Returns a message object on success.
	GetMessage(ctx context.Context, channelID, messageID Snowflake, flags ...Flag) (ret *Message, err error)

	// CreateMessage Post a message to a guild text or DM channel. If operating on a guild channel, this
	// endpoint requires the 'SEND_MESSAGES' permission to be present on the current user. If the tts field is set to true,
	// the SEND_TTS_MESSAGES permission is required for the message to be spoken. Returns a message object. Fires a
	// Message Create Gateway event. See message formatting for more information on how to properly format messages.
	// The maximum request size when sending a message is 8MB.
	CreateMessage(ctx context.Context, channelID Snowflake, params *CreateMessageParams, flags ...Flag) (ret *Message, err error)

	// UpdateMessage Edit a previously sent message. You can only edit messages that have been sent by the
	// current user. Returns a message object. Fires a Message Update Gateway event.
	UpdateMessage(ctx context.Context, chanID, msgID Snowflake, flags ...Flag) *updateMessageBuilder
	SetMsgContent(ctx context.Context, chanID, msgID Snowflake, content string) (*Message, error)
	SetMsgEmbed(ctx context.Context, chanID, msgID Snowflake, embed *Embed) (*Message, error)

	// DeleteMessage Delete a message. If operating on a guild channel and trying to delete a message that was not
	// sent by the current user, this endpoint requires the 'MANAGE_MESSAGES' permission. Returns a 204 empty response
	// on success. Fires a Message Delete Gateway event.
	DeleteMessage(ctx context.Context, channelID, msgID Snowflake, flags ...Flag) (err error)

	// DeleteMessages Delete multiple messages in a single request. This endpoint can only be used on guild
	// Channels and requires the 'MANAGE_MESSAGES' permission. Returns a 204 empty response on success. Fires multiple
	// Message Delete Gateway events.Any message IDs given that do not exist or are invalid will count towards
	// the minimum and maximum message count (currently 2 and 100 respectively). Additionally, duplicated IDs
	// will only be counted once.
	DeleteMessages(ctx context.Context, chanID Snowflake, params *DeleteMessagesParams, flags ...Flag) (err error)
}

type RESTMethods

RESTer holds all the sub REST interfaces

type RESTReaction

type RESTReaction interface {
	// CreateReaction Create a reaction for the message. This endpoint requires the 'READ_MESSAGE_HISTORY'
	// permission to be present on the current user. Additionally, if nobody else has reacted to the message using this
	// emoji, this endpoint requires the 'ADD_REACTIONS' permission to be present on the current user. Returns a 204
	// empty response on success. The maximum request size when sending a message is 8MB.
	CreateReaction(ctx context.Context, channelID, messageID Snowflake, emoji interface{}, flags ...Flag) (err error)

	// DeleteOwnReaction Delete a reaction the current user has made for the message.
	// Returns a 204 empty response on success.
	DeleteOwnReaction(ctx context.Context, channelID, messageID Snowflake, emoji interface{}, flags ...Flag) (err error)

	// DeleteUserReaction Deletes another user's reaction. This endpoint requires the 'MANAGE_MESSAGES' permission
	// to be present on the current user. Returns a 204 empty response on success.
	DeleteUserReaction(ctx context.Context, channelID, messageID, userID Snowflake, emoji interface{}, flags ...Flag) (err error)

	// GetReaction Get a list of Users that reacted with this emoji. Returns an array of user objects on success.
	GetReaction(ctx context.Context, channelID, messageID Snowflake, emoji interface{}, params URLQueryStringer, flags ...Flag) (reactors []*User, err error)

	// DeleteAllReactions Deletes all reactions on a message. This endpoint requires the 'MANAGE_MESSAGES'
	// permission to be present on the current user.
	DeleteAllReactions(ctx context.Context, channelID, messageID Snowflake, flags ...Flag) (err error)
}

type RESTUser

type RESTUser interface {
	// GetCurrentUser Returns the user object of the requester's account. For OAuth2, this requires the identify
	// scope, which will return the object without an email, and optionally the email scope, which returns the object
	// with an email.
	GetCurrentUser(ctx context.Context, flags ...Flag) (*User, error)

	// GetUser Returns a user object for a given user Snowflake.
	GetUser(ctx context.Context, id Snowflake, flags ...Flag) (*User, error)

	// UpdateCurrentUser Modify the requester's user account settings. Returns a user object on success.
	UpdateCurrentUser(ctx context.Context, flags ...Flag) (builder *updateCurrentUserBuilder)

	// GetCurrentUserGuilds Returns a list of partial guild objects the current user is a member of.
	// Requires the Guilds OAuth2 scope.
	GetCurrentUserGuilds(ctx context.Context, params *GetCurrentUserGuildsParams, flags ...Flag) (ret []*PartialGuild, err error)

	// LeaveGuild Leave a guild. Returns a 204 empty response on success.
	LeaveGuild(ctx context.Context, id Snowflake, flags ...Flag) (err error)

	// GetUserDMs Returns a list of DM channel objects.
	GetUserDMs(ctx context.Context, flags ...Flag) (ret []*Channel, err error)

	// CreateDM Create a new DM channel with a user. Returns a DM channel object.
	CreateDM(ctx context.Context, recipientID Snowflake, flags ...Flag) (ret *Channel, err error)

	// CreateGroupDM Create a new group DM channel with multiple Users. Returns a DM channel object.
	// This endpoint was intended to be used with the now-deprecated GameBridge SDK. DMs created with this
	// endpoint will not be shown in the Discord Client
	CreateGroupDM(ctx context.Context, params *CreateGroupDMParams, flags ...Flag) (ret *Channel, err error)

	// GetUserConnections Returns a list of connection objects. Requires the connections OAuth2 scope.
	GetUserConnections(ctx context.Context, flags ...Flag) (ret []*UserConnection, err error)
}

RESTUser REST interface for all user endpoints

type RESTVoice

type RESTVoice interface {
	// GetVoiceRegionsBuilder Returns an array of voice region objects that can be used when creating servers.
	GetVoiceRegions(ctx context.Context, flags ...Flag) ([]*VoiceRegion, error)
}

RESTVoice REST interface for all voice endpoints

type RESTWebhook

type RESTWebhook interface {
	// CreateWebhook Create a new webhook. Requires the 'MANAGE_WEBHOOKS' permission.
	// Returns a webhook object on success.
	CreateWebhook(ctx context.Context, channelID Snowflake, params *CreateWebhookParams, flags ...Flag) (ret *Webhook, err error)

	// GetChannelWebhooks Returns a list of channel webhook objects. Requires the 'MANAGE_WEBHOOKS' permission.
	GetChannelWebhooks(ctx context.Context, channelID Snowflake, flags ...Flag) (ret []*Webhook, err error)

	// GetGuildWebhooks Returns a list of guild webhook objects. Requires the 'MANAGE_WEBHOOKS' permission.
	GetGuildWebhooks(ctx context.Context, guildID Snowflake, flags ...Flag) (ret []*Webhook, err error)

	// GetWebhook Returns the new webhook object for the given id.
	GetWebhook(ctx context.Context, id Snowflake, flags ...Flag) (ret *Webhook, err error)

	// GetWebhookWithToken Same as GetWebhook, except this call does not require authentication and
	// returns no user in the webhook object.
	GetWebhookWithToken(ctx context.Context, id Snowflake, token string, flags ...Flag) (ret *Webhook, err error)

	// UpdateWebhook Modify a webhook. Requires the 'MANAGE_WEBHOOKS' permission.
	// Returns the updated webhook object on success.
	UpdateWebhook(ctx context.Context, id Snowflake, flags ...Flag) (builder *updateWebhookBuilder)

	// UpdateWebhookWithToken Same as UpdateWebhook, except this call does not require authentication,
	// does _not_ accept a channel_id parameter in the body, and does not return a user in the webhook object.
	UpdateWebhookWithToken(ctx context.Context, id Snowflake, token string, flags ...Flag) (builder *updateWebhookBuilder)

	// DeleteWebhook Delete a webhook permanently. User must be owner. Returns a 204 NO CONTENT response on success.
	DeleteWebhook(ctx context.Context, webhookID Snowflake, flags ...Flag) error

	// DeleteWebhookWithToken Same as DeleteWebhook, except this call does not require authentication.
	DeleteWebhookWithToken(ctx context.Context, id Snowflake, token string, flags ...Flag) error

	// ExecuteWebhook Trigger a webhook in Discord.
	ExecuteWebhook(ctx context.Context, params *ExecuteWebhookParams, wait bool, URLSuffix string, flags ...Flag) error

	// ExecuteSlackWebhook Trigger a webhook in Discord from the Slack app.
	ExecuteSlackWebhook(ctx context.Context, params *ExecuteWebhookParams, wait bool, flags ...Flag) error

	// ExecuteGitHubWebhook Trigger a webhook in Discord from the GitHub app.
	ExecuteGitHubWebhook(ctx context.Context, params *ExecuteWebhookParams, wait bool, flags ...Flag) error
}

RESTWebhook REST interface for all Webhook endpoints

type Reaction

type Reaction struct {
	Lockable `json:"-"`

	Count uint          `json:"count"`
	Me    bool          `json:"me"`
	Emoji *PartialEmoji `json:"Emoji"`
}

Reaction ... https://discordapp.com/developers/docs/resources/channel#reaction-object