api

type Activity struct {
	Name          string              `json:"name"`
	Type          ActivityType        `json:"type"`
	URL           *string             `json:"url"`
	CreatedAt     time.Time           `json:"created_at"`
	Timestamps    *ActivityTimestamps `json:"timestamps,omitempty"`
	ApplicationID Snowflake           `json:"application_id,omitempty"`
	Details       *string             `json:"details,omitempty"`
	State         *string             `json:"state,omitempty"`
	Emoji         *ActivityEmoji      `json:"emoji,omitempty"`
	Party         *ActivityParty      `json:"party,omitempty"`
	Assets        *ActivityAssets     `json:"assets,omitempty"`
	Secrets       *ActivitySecrets    `json:"secrets,omitempty"`
	Instance      *bool               `json:"instance,omitempty"`
	Flags         int                 `json:"flags,omitempty"`
}

type ActivityAssets struct {
	LargeImage string `json:"large_image,omitempty"`
	LargeText  string `json:"large_text,omitempty"`
	SmallImage string `json:"small_image,omitempty"`
	SmallText  string `json:"small_text,omitempty"`
}

type ActivityEmoji struct {
	Name     string     `json:"name"`
	ID       *Snowflake `json:"id,omitempty"`
	Animated *bool      `json:"animated,omitempty"`
}

type ActivityParty struct {
	ID   Snowflake `json:"id,omitempty"`
	Size []int     `json:"size,omitempty"`
}

type ActivitySecrets struct {
	Join     string `json:"join,omitempty"`
	Spectate string `json:"spectate,omitempty"`
	Match    string `json:"match,omitempty"`
}

type ActivityTimestamps struct {
	Start *time.Time `json:"start,omitempty"`
	End   *time.Time `json:"end,omitempty"`
}

type ActivityType int

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

type AllowedMentionType string

type AllowedMentions struct {
	Parse       []AllowedMentionType `json:"parse"`
	Roles       []Snowflake          `json:"roles"`
	Users       []Snowflake          `json:"users"`
	RepliedUser bool                 `json:"replied_user"`
}

type Bit interface {
	Add(bits ...Bit) Bit
	Remove(bits ...Bit) Bit
	HasAll(bits ...Bit) bool
	Has(bit Bit) bool
	MissingAny(bits ...Bit) bool
	Missing(bit Bit) bool
}

type Cache interface {
	Close()
	DoCleanup()

	Guild(Snowflake) *Guild
	GuildsByName(string, bool) []*Guild
	Guilds() []*Guild
	GuildCache() map[Snowflake]*Guild
	CacheGuild(*Guild)
	UncacheGuild(Snowflake)

	User(Snowflake) *User
	UserByTag(string) *User
	UsersByName(string, bool) []*User
	Users() []*User
	UserCache() map[Snowflake]*User
	CacheUser(*User)
	UncacheUser(Snowflake)
	FindUser(func(*User) bool) *User
	FindUsers(func(*User) bool) []*User

	Member(Snowflake, Snowflake) *Member
	MemberByTag(Snowflake, string) *Member
	MembersByName(Snowflake, string, bool) []*Member
	Members(Snowflake) []*Member
	AllMembers() []*Member
	MemberCache(Snowflake) map[Snowflake]*Member
	AllMemberCache() map[Snowflake]map[Snowflake]*Member
	CacheMember(*Member)
	UncacheMember(Snowflake, Snowflake)
	FindMember(Snowflake, func(*Member) bool) *Member
	FindMembers(Snowflake, func(*Member) bool) []*Member

	Role(Snowflake, Snowflake) *Role
	RolesByName(Snowflake, string, bool) []*Role
	Roles(Snowflake) []*Role
	AllRoles() []*Role
	RoleCache(Snowflake) map[Snowflake]*Role
	AllRoleCache() map[Snowflake]map[Snowflake]*Role
	CacheRole(*Role)
	UncacheRole(Snowflake, Snowflake)
	FindRole(Snowflake, func(*Role) bool) *Role
	FindRoles(Snowflake, func(*Role) bool) []*Role

	DMChannel(Snowflake) *DMChannel
	DMChannels() []*DMChannel
	DMChannelCache() map[Snowflake]*DMChannel
	CacheDMChannel(*DMChannel)
	UncacheDMChannel(Snowflake)
	FindDMChannel(func(*DMChannel) bool) *DMChannel
	FindDMChannels(func(*DMChannel) bool) []*DMChannel

	Channel(Snowflake) *Channel
	MessageChannel(Snowflake) *MessageChannel
	GuildChannel(Snowflake) *GuildChannel

	TextChannel(Snowflake) *TextChannel
	TextChannelsByName(Snowflake, string, bool) []*TextChannel
	TextChannels(Snowflake) []*TextChannel
	TextChannelCache(Snowflake) map[Snowflake]*TextChannel
	CacheTextChannel(*TextChannel)
	UncacheTextChannel(Snowflake, Snowflake)
	FindTextChannel(Snowflake, func(*TextChannel) bool) *TextChannel
	FindTextChannels(Snowflake, func(*TextChannel) bool) []*TextChannel

	StoreChannel(Snowflake) *StoreChannel
	StoreChannelsByName(Snowflake, string, bool) []*StoreChannel
	StoreChannels(Snowflake) []*StoreChannel
	StoreChannelCache(Snowflake) map[Snowflake]*StoreChannel
	CacheStoreChannel(*StoreChannel)
	UncacheStoreChannel(Snowflake, Snowflake)
	FindStoreChannel(Snowflake, func(*StoreChannel) bool) *StoreChannel
	FindStoreChannels(Snowflake, func(*StoreChannel) bool) []*StoreChannel

	VoiceChannel(Snowflake) *VoiceChannel
	VoiceChannelsByName(Snowflake, string, bool) []*VoiceChannel
	VoiceChannels(Snowflake) []*VoiceChannel
	VoiceChannelCache(Snowflake) map[Snowflake]*VoiceChannel
	CacheVoiceChannel(*VoiceChannel)
	UncacheVoiceChannel(Snowflake, Snowflake)
	FindVoiceChannel(Snowflake, func(*VoiceChannel) bool) *VoiceChannel
	FindVoiceChannels(Snowflake, func(*VoiceChannel) bool) []*VoiceChannel

	Category(Snowflake) *Category
	CategoriesByName(Snowflake, string, bool) []*Category
	Categories(Snowflake) []*Category
	AllCategories() []*Category
	CategoryCache(Snowflake) map[Snowflake]*Category
	AllCategoryCache() map[Snowflake]map[Snowflake]*Category
	CacheCategory(*Category)
	UncacheCategory(Snowflake, Snowflake)
	FindCategory(Snowflake, func(*Category) bool) *Category
	FindCategories(Snowflake, func(*Category) bool) []*Category
}

type Category struct {
	GuildChannel
}

type Channel struct {
	Disgo            Disgo
	ID               Snowflake    `json:"id"`
	Name             *string      `json:"name,omitempty"`
	Type             ChannelType  `json:"type"`
	LastMessageID    *Snowflake   `json:"last_message_id,omitempty"`
	GuildID          *Snowflake   `json:"guild_id,omitempty"`
	Position         *int         `json:"position,omitempty"`
	Topic            *string      `json:"topic,omitempty"`
	NSFW             *bool        `json:"nsfw,omitempty"`
	Bitrate          *int         `json:"bitrate,omitempty"`
	UserLimit        *int         `json:"user_limit,omitempty"`
	RateLimitPerUser *int         `json:"rate_limit_per_user,omitempty"`
	Recipients       []*User      `json:"recipients,omitempty"`
	Icon             *string      `json:"icon,omitempty"`
	OwnerID          *Snowflake   `json:"owner_id,omitempty"`
	ApplicationID    *Snowflake   `json:"application_id,omitempty"`
	ParentID         *Snowflake   `json:"parent_id,omitempty"`
	Permissions      *Permissions `json:"permissions,omitempty"`
}

type ChannelType int

type Color int

type CommandOption struct {
	Type        SlashCommandOptionType `json:"type"`
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	Required    bool                   `json:"required,omitempty"`
	Choices     []OptionChoice         `json:"choices,omitempty"`
	Options     []CommandOption        `json:"options,omitempty"`
}

type ConnectionStatus int

type DMChannel struct {
	MessageChannel
	Users []User `json:"recipients"`
}

type DeconstructedSnowflake struct {
	Timestamp int64
	WorkerID  int64
	ProcessID int64
	Increment int64
	Binary    string
}

type Disgo interface {
	Connect() error
	Start() error
	Close()
	Token() string
	Gateway() Gateway
	RestClient() RestClient
	WebhookServer() WebhookServer
	Cache() Cache
	Intents() Intents
	ApplicationID() Snowflake
	SelfUser() *User
	SetSelfUser(*User)
	EventManager() EventManager
	HeartbeatLatency() time.Duration

	GetCommand(commandID Snowflake) (*SlashCommand, error)
	GetCommands() ([]*SlashCommand, error)
	CreateCommand(command SlashCommand) (*SlashCommand, error)
	EditCommand(commandID Snowflake, command SlashCommand) (*SlashCommand, error)
	DeleteCommand(command SlashCommand) (*SlashCommand, error)
	SetCommands(commands ...SlashCommand) ([]*SlashCommand, error)
}

type DisgoBuilder interface {
	SetLogLevel(level log.Level) DisgoBuilder
	SetToken(token string) DisgoBuilder
	SetIntents(intents Intents) DisgoBuilder
	SetEventManager(eventManager EventManager) DisgoBuilder
	AddEventListeners(eventsListeners ...EventListener) DisgoBuilder
	SetWebhookServer(webhookServer WebhookServer) DisgoBuilder
	SetWebhookServerProperties(listenURL string, listenPort int, publicKey string) DisgoBuilder
	SetRestClient(restClient RestClient) DisgoBuilder
	SetCache(cache Cache) DisgoBuilder
	SetMemberCachePolicy(memberCachePolicy MemberCachePolicy) DisgoBuilder
	SetGateway(gateway Gateway) DisgoBuilder
	Build() (Disgo, error)
}

type Embed struct {
	Title       *string        `json:"title,omitempty"`
	Type        *EmbedType     `json:"type,omitempty"`
	Description *string        `json:"description,omitempty"`
	URL         *string        `json:"url,omitempty"`
	Timestamp   *time.Time     `json:"timestamp,omitempty"`
	Color       *int           `json:"color,omitempty"`
	Footer      *EmbedFooter   `json:"footer,omitempty"`
	Image       *EmbedResource `json:"image,omitempty"`
	Thumbnail   *EmbedResource `json:"thumbnail,omitempty"`
	Video       *EmbedResource `json:"video,omitempty"`
	Provider    *EmbedProvider `json:"provider,omitempty"`
	Author      *EmbedAuthor   `json:"author,omitempty"`
	Fields      []*EmbedField  `json:"fields,omitempty"`
}

type EmbedAuthor struct {
	Name         *string `json:"name,omitempty"`
	URL          *string `json:"url,omitempty"`
	IconURL      *string `json:"icon_url,omitempty"`
	ProxyIconURL *string `json:"proxy_icon_url,omitempty"`
}

type EmbedBuilder struct {
	Embed
}

type EmbedField struct {
	Name   string `json:"name"`
	Value  string `json:"value"`
	Inline *bool  `json:"inline,omitempty"`
}

type EmbedFooter struct {
	Text         string  `json:"text"`
	IconURL      *string `json:"icon_url,omitempty"`
	ProxyIconURL *string `json:"proxy_icon_url,omitempty"`
}

type EmbedProvider struct {
	Name *string `json:"name,omitempty"`
	URL  *string `json:"url,omitempty"`
}

type EmbedResource struct {
	URL      *string `json:"url,omitempty"`
	ProxyURL *string `json:"proxy_url,omitempty"`
	Height   *int    `json:"height,omitempty"`
	Width    *int    `json:"width,omitempty"`
}

type EmbedType string

type Emote struct {
	ID       Snowflake
	Name     string
	Animated bool
}

type ErrorResponse struct {
	Code    int
	Message string
}

type Event struct {
	Disgo Disgo
}

type EventHandler interface {
	Name() string
	New() interface{}
}

type EventListener interface {
	OnEvent(interface{})
}

type EventManager interface {
	AddEventListeners(...EventListener)
	Handle(string, json.RawMessage, chan interface{})
	Dispatch(GenericEvent)
}

type ExplicitContentFilterLevel int

type FollowupMessage struct {
}

type Gateway interface {
	Disgo() Disgo
	Open() error
	Status() ConnectionStatus
	Close()
	Latency() time.Duration
}

type GatewayBotRs struct {
	URL               string `json:"url"`
	Shards            int    `json:"shards"`
	SessionStartLimit struct {
		Total          int `json:"total"`
		Remaining      int `json:"remaining"`
		ResetAfter     int `json:"reset_after"`
		MaxConcurrency int `json:"max_concurrency"`
	} `json:"session_start_limit"`
}

type GatewayCommand struct {
	Op GatewayOp `json:"op"`
	S  *int      `json:"s,omitempty"`
	T  *string   `json:"t,omitempty"`
}

type GatewayEventHandler interface {
	EventHandler
	Handle(Disgo, EventManager, interface{})
}

type GatewayOp int

type GatewayRs struct {
	URL string `json:"url"`
}

type GenericEvent interface{}

type Guild struct {
	Disgo                       Disgo
	ID                          Snowflake                  `json:"id"`
	Name                        string                     `json:"name"`
	Icon                        *string                    `json:"icon"`
	Region                      string                     `json:"region"`
	OwnerID                     Snowflake                  `json:"owner_id"`
	JoinedAt                    *time.Time                 `json:"joined_at"`
	DiscoverySplash             *string                    `json:"discovery_splash"`
	Splash                      *string                    `json:"splash"`
	AfkChannelID                *Snowflake                 `json:"afk_channel_id"`
	AfkTimeout                  int                        `json:"afk_timeout"`
	MemberCount                 *int                       `json:"member_count"`
	VerificationLevel           VerificationLevel          `json:"verification_level"`
	Large                       *bool                      `json:"large"`
	DefaultMessageNotifications MessageNotifications       `json:"default_message_notifications"`
	Roles                       []*Role                    `json:"roles"`
	Emojis                      []*Emote                   `json:"emojis"`
	Members                     []*Member                  `json:"members"`
	MaxPresences                *int                       `json:"max_presences"`
	MaxMembers                  *int                       `json:"max_members"`
	Channels                    []*GuildChannel            `json:"channels"`
	VoiceStates                 []*VoiceState              `json:"voice_states"`
	Unavailable                 bool                       `json:"unavailable"`
	ExplicitContentFilter       ExplicitContentFilterLevel `json:"explicit_content_filter"`
	Features                    []GuildFeature             `json:"features"`
	MfaLevel                    MFALevel                   `json:"mfa_level"`
	ApplicationID               Snowflake                  `json:"application_id"`
	WidgetEnabled               bool                       `json:"widget_enabled"`
	WidgetChannelID             Snowflake                  `json:"widget_channel_id"`
	SystemChannelID             Snowflake                  `json:"system_channel_id"`
	SystemChannelFlags          SystemChannelFlag          `json:"system_channel_flags"`
	RulesChannelID              Snowflake                  `json:"rules_channel_id"`
	VanityURLCode               *string                    `json:"vanity_url_code"`
	Description                 *string                    `json:"description"`
	Banner                      *string                    `json:"banner"`
	PremiumTier                 PremiumTier                `json:"premium_tier"`
	PremiumSubscriptionCount    *int                       `json:"premium_subscription_count"`
	PreferredLocale             string                     `json:"preferred_locale"`
	PublicUpdatesChannelID      *Snowflake                 `json:"public_updates_channel_id"`
	MaxVideoChannelUsers        *int                       `json:"max_video_channel_users"`
	ApproximateMemberCount      *int                       `json:"approximate_member_count"`
	ApproximatePresenceCount    *int                       `json:"approximate_presence_count"`
}

type GuildChannel struct {
	Channel
	GuildID Snowflake `json:"guild_id"`
}

type GuildFeature string

type HeartbeatCommand struct {
	GatewayCommand
	D *int `json:"d"`
}

type HelloEvent struct {
	GatewayCommand
	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
}

type IdentifyCommand struct {
	GatewayCommand
	D IdentifyCommandData `json:"d"`
}

type IdentifyCommandData struct {
	Token              string                        `json:"token"`
	Properties         IdentifyCommandDataProperties `json:"properties"`
	Compress           bool                          `json:"compress,omitempty"`
	LargeThreshold     int                           `json:"large_threshold,omitempty"`
	GuildSubscriptions bool                          `json:"guild_subscriptions,omitempty"` // Deprecated, should not be specified when using intents
	Intents            Intents                       `json:"intents"`
}

type IdentifyCommandDataProperties struct {
	OS      string `json:"$os"`      // user OS
	Browser string `json:"$browser"` // library name
	Device  string `json:"$device"`  // library name
}

type Intents int64

type Interaction struct {
	ID        Snowflake        `json:"id"`
	Type      InteractionType  `json:"type"`
	Data      *InteractionData `json:"data,omitempty"`
	GuildID   *Snowflake       `json:"guild_id,omitempty"`
	ChannelID *Snowflake       `json:"channel_id,omitempty"`
	Member    *Member          `json:"member,omitempty"`
	User      *User            `json:"User,omitempty"`
	Token     string           `json:"token"`
	Version   int              `json:"version"`
}

type InteractionData struct {
	ID       Snowflake     `json:"id"`
	Name     string        `json:"name"`
	Resolved *Resolved     `json:"resolved"`
	Options  []*OptionData `json:"options,omitempty"`
}

type InteractionResponse struct {
	Type InteractionResponseType  `json:"type"`
	Data *InteractionResponseData `json:"data,omitempty"`
}

type InteractionResponseBuilder struct {
	InteractionResponse
}

type InteractionResponseData struct {
	TTS             bool             `json:"tts,omitempty"`
	Content         string           `json:"content,omitempty"`
	Embeds          []Embed          `json:"embeds,omitempty"`
	AllowedMentions *AllowedMentions `json:"allowed_mentions,omitempty"`
	Flags           MessageFlags     `json:"flags,omitempty"`
}

type InteractionResponseType int

type InteractionType int

type MFALevel int

type Member struct {
	Disgo        Disgo
	GuildID      Snowflake    `json:"guild_id"`
	User         *User        `json:"user"`
	Nick         *string      `json:"nick"`
	Roles        []Snowflake  `json:"roles,omitempty"`
	JoinedAt     time.Time    `json:"joined_at"`
	PremiumSince *time.Time   `json:"premium_since,omitempty"`
	Deaf         *bool        `json:"deaf,omitempty"`
	Mute         *bool        `json:"mute,omitempty"`
	Pending      bool         `json:"pending"`
	Permissions  *Permissions `json:"permissions,omitempty"`
}

type MemberCachePolicy func(*Member) bool

type Mentionable interface {
	Mention() string
}

type Message struct {
	Disgo            Disgo
	ID               Snowflake         `json:"id"`
	GuildID          *Snowflake        `json:"guild_id"`
	Reactions        []Reactions       `json:"reactions"`
	Attachments      []interface{}     `json:"attachments"`
	Tts              bool              `json:"tts"`
	Embeds           []*Embed          `json:"embeds,omitempty"`
	CreatedAt        time.Time         `json:"timestamp"`
	MentionEveryone  bool              `json:"mention_everyone"`
	Pinned           bool              `json:"pinned"`
	EditedTimestamp  interface{}       `json:"edited_timestamp"`
	Author           User              `json:"author"`
	MentionRoles     []interface{}     `json:"mention_roles"`
	Content          *string           `json:"content,omitempty"`
	ChannelID        Snowflake         `json:"channel_id"`
	Mentions         []interface{}     `json:"mentions"`
	MessageType      MessageType       `json:"type"`
	MessageReference *MessageReference `json:"message_reference,omitempty"`
	LastUpdated      *time.Time
}

type MessageBuilder struct {
	MessageCreate
}

type MessageCachePolicy func(*Message) bool

type MessageChannel struct {
	Channel
}

type MessageCreate struct {
	Content          string            `json:"content,omitempty"`
	TTS              bool              `json:"tts,omitempty"`
	Embed            *Embed            `json:"embed,omitempty"`
	AllowedMentions  *AllowedMentions  `json:"allowed_mentions,omitempty"`
	MessageReference *MessageReference `json:"message_reference,omitempty"`
}

type MessageFlags int64

type MessageInteraction struct {
	ID   Snowflake       `json:"id"`
	Type InteractionType `json:"type"`
	Name string          `json:"name"`
	User User            `json:"user"`
}

type MessageNotifications int

type MessageReference struct {
	MessageID       *Snowflake `json:"message_id"`
	ChannelID       *Snowflake `json:"channel_id,omitempty"`
	GuildID         *Snowflake `json:"guild_id,omitempty"`
	FailIfNotExists *bool      `json:"fail_if_not_exists,omitempty"`
}

type MessageType int

type MoveGuildMemberData struct {
	ChannelID *Snowflake `json:"channel_id"`
}

type OptionChoice struct {
	Name  string      `json:"name"`
	Value interface{} `json:"value"`
}

type OptionData struct {
	Name    string                 `json:"name"`
	Type    SlashCommandOptionType `json:"type"`
	Value   interface{}            `json:"value,omitempty"`
	Options []*OptionData          `json:"options,omitempty"`
}

type Options struct {
	Intents                   Intents
	RestTimeout               int
	EnableWebhookInteractions bool
	ListenPort                int
	ListenURL                 string
	PublicKey                 string
}

type Permissions int64

type PremiumTier int

type RawGatewayCommand struct {
	GatewayCommand
	D json.RawMessage `json:"d"`
}

type Reactions struct {
	Count int   `json:"count"`
	Me    bool  `json:"me"`
	Emoji Emote `json:"emoji"`
}

type ReadyEvent struct {
	GatewayCommand
	D ReadyEventData `json:"d"`
}

type ReadyEventData struct {
	User            User        `json:"user"`
	PrivateChannels []DMChannel `json:"channel"`
	Guilds          []Guild     `json:"guild_events"`
	SessionID       string      `json:"session_id"`
	Shard           [2]int      `json:"shard,omitempty"`
}

type RequestGuildMembersCommand struct {
	GatewayCommand
	D RequestGuildMembersCommandData `json:"d"`
}

type RequestGuildMembersCommandData struct {
	GuildID   Snowflake   `json:"guild_id"`
	Query     string      `json:"query"` //If specified, user_ids must not be entered
	Limit     int         `json:"limit"` //Must be >=1 if query/user_ids is used, otherwise 0
	Presences bool        `json:"presences,omitempty"`
	UserIDs   []Snowflake `json:"user_ids"`        //If specified, query must not be entered
	Nonce     string      `json:"nonce,omitempty"` //All responses are hashed with this nonce, optional
}

type Resolved struct {
	Users    map[Snowflake]*User    `json:"users,omitempty"`
	Members  map[Snowflake]*Member  `json:"members,omitempty"`
	Roles    map[Snowflake]*Role    `json:"roles,omitempty"`
	Channels map[Snowflake]*Channel `json:"channels,omitempty"`
}

type RestClient interface {
	Close()
	Disgo() Disgo

	UserAgent() string
	Request(route endpoints.CompiledAPIRoute, rqBody interface{}, rsBody interface{}) error

	SendMessage(channelID Snowflake, message MessageCreate) (*Message, error)
	OpenDMChannel(userID Snowflake) (*DMChannel, error)

	UpdateSelfNick(guildID Snowflake, nick *string) (*string, error)

	GetUser(userID Snowflake) (*User, error)
	GetMember(guildID Snowflake, userID Snowflake) (*Member, error)
	GetMembers(guildID Snowflake) ([]*Member, error)
	AddMember(guildID Snowflake, userID Snowflake, addGuildMemberData AddGuildMemberData) (*Member, error)
	KickMember(guildID Snowflake, userID Snowflake, reason *string) error
	UpdateMember(guildID Snowflake, userID Snowflake, updateGuildMemberData UpdateGuildMemberData) (*Member, error)
	MoveMember(guildID Snowflake, userID Snowflake, channelID *Snowflake) (*Member, error)
	AddMemberRole(guildID Snowflake, userID Snowflake, roleID Snowflake) error
	RemoveMemberRole(guildID Snowflake, userID Snowflake, roleID Snowflake) error

	GetRoles(guildID Snowflake) ([]*Role, error)
	CreateRole(guildID Snowflake, role UpdateRole) (*Role, error)
	UpdateRole(guildID Snowflake, roleID Snowflake, role UpdateRole) (*Role, error)
	UpdateRolePositions(guildID Snowflake, roleUpdates ...UpdateRolePosition) ([]*Role, error)
	DeleteRole(guildID Snowflake, roleID Snowflake) error

	AddReaction(channelID Snowflake, messageID Snowflake, emoji string) error
	RemoveOwnReaction(channelID Snowflake, messageID Snowflake, emoji string) error
	RemoveUserReaction(channelID Snowflake, messageID Snowflake, emoji string, userID Snowflake) error

	GetGlobalCommands(applicationID Snowflake) ([]*SlashCommand, error)
	CreateGlobalCommand(applicationID Snowflake, command SlashCommand) (*SlashCommand, error)
	SetGlobalCommands(applicationID Snowflake, commands ...SlashCommand) ([]*SlashCommand, error)
	GetGlobalCommand(applicationID Snowflake, commandID Snowflake) (*SlashCommand, error)
	EditGlobalCommand(applicationID Snowflake, commandID Snowflake, command SlashCommand) (*SlashCommand, error)
	DeleteGlobalCommand(applicationID Snowflake, commandID Snowflake) error

	GetGuildCommands(applicationID Snowflake, guildID Snowflake) ([]*SlashCommand, error)
	CreateGuildGuildCommand(applicationID Snowflake, guildID Snowflake, command SlashCommand) (*SlashCommand, error)
	SetGuildCommands(applicationID Snowflake, guildID Snowflake, commands ...SlashCommand) ([]*SlashCommand, error)
	GetGuildCommand(applicationID Snowflake, guildID Snowflake, commandID Snowflake) (*SlashCommand, error)
	EditGuildCommand(applicationID Snowflake, guildID Snowflake, commandID Snowflake, command SlashCommand) (*SlashCommand, error)
	DeleteGuildCommand(applicationID Snowflake, guildID Snowflake, commandID Snowflake) error

	SendInteractionResponse(interactionID Snowflake, interactionToken string, interactionResponse InteractionResponse) error
	EditInteractionResponse(applicationID Snowflake, interactionToken string, interactionResponse InteractionResponse) (*Message, error)
	DeleteInteractionResponse(applicationID Snowflake, interactionToken string) error

	SendFollowupMessage(applicationID Snowflake, interactionToken string, followupMessage FollowupMessage) (*Message, error)
	EditFollowupMessage(applicationID Snowflake, interactionToken string, messageID Snowflake, followupMessage FollowupMessage) (*Message, error)
	DeleteFollowupMessage(applicationID Snowflake, interactionToken string, followupMessageID Snowflake) error
}

type ResumeCommand struct {
	GatewayCommand
	D struct {
		Token     string `json:"token"`
		SessionID string `json:"session_id"`
		Seq       int    `json:"seq"`
	} `json:"d"`
}

type Role struct {
	Disgo       Disgo
	GuildID     Snowflake
	ID          Snowflake   `json:"id"`
	Name        string      `json:"name"`
	Color       Color       `json:"color"`
	Hoist       bool        `json:"hoist"`
	Position    int         `json:"position"`
	Permissions Permissions `json:"permissions"`
	Managed     bool        `json:"managed"`
	Mentionable bool        `json:"mentionable"`
	Tags        *RoleTag    `json:"tags,omitempty"`
}

type RoleTag struct {
	BotID             *Snowflake `json:"bot_id,omitempty"`
	IntegrationID     *Snowflake `json:"integration_id,omitempty"`
	PremiumSubscriber bool       `json:"premium_subscriber"`
}

type SlashCommand struct {
	ID            Snowflake        `json:"id,omitempty"`
	ApplicationID Snowflake        `json:"application_id,omitempty"`
	Name          string           `json:"name"`
	Description   string           `json:"description"`
	Options       []*CommandOption `json:"options,omitempty"`
}

type SlashCommandOptionType int

type Snowflake string

type StoreChannel struct {
	GuildChannel
}

type SystemChannelFlag int

type TextChannel struct {
	GuildChannel
	MessageChannel
}

type UpdateGuildMemberData struct {
	Nick  *string     `json:"nick,omitempty"`
	Roles []Snowflake `json:"roles,omitempty"`
	Mute  *bool       `json:"mute,omitempty"`
	Deaf  *bool       `json:"deaf,omitempty"`
}

type UpdateMessage struct {
	Content         *string          `json:"content,omitempty"`
	Embed           *Embed           `json:"embed,omitempty"`
	Flags           *MessageFlags    `json:"flags,omitempty"`
	AllowedMentions *AllowedMentions `json:"allowed_mentions,omitempty"`
}

type UpdateRole struct {
	Name        *string      `json:"name,omitempty"`
	Permissions *Permissions `json:"permissions,omitempty"`
	Color       *Color       `json:"color,omitempty"`
	Hoist       *bool        `json:"hoist,omitempty"`
	Mentionable *bool        `json:"mentionable,omitempty"`
}

type UpdateRolePosition struct {
	ID       Snowflake `json:"id"`
	Position *int      `json:"position"`
}

type UpdateSelfNick struct {
	Nick *string `json:"nick"`
}

type UpdateStatusCommand struct {
	GatewayCommand
	D UpdateStatusCommandData `json:"d"`
}

type UpdateStatusCommandData struct {
	Since      *int       `json:"since"`
	Activities []Activity `json:"activities"`
	Status     bool       `json:"status"`
	AFK        bool       `json:"afk"`
}

type UpdateVoiceStateCommand struct {
	GatewayCommand
	D UpdateVoiceStateCommandData `json:"d"`
}

type UpdateVoiceStateCommandData struct {
	GuildID   Snowflake `json:"guild_id"`
	ChannelID Snowflake `json:"channel_id"`
	SelfMute  bool      `json:"self_mute"`
	SelfDeaf  bool      `json:"self_deaf"`
}

type User struct {
	Disgo         Disgo
	ID            Snowflake `json:"id"`
	Username      string    `json:"username"`
	Discriminator string    `json:"discriminator"`
	Avatar        *string   `json:"avatar"`
	IsBot         bool      `json:"bot"`
	System        *bool     `json:"system"`
	MfaEnabled    *bool     `json:"mfa_enabled"`
	Locale        *string   `json:"locale"`
	Verified      *bool     `json:"verified"`
	Email         *string   `json:"email"`
	Flags         *int      `json:"flags"`
	PremiumType   *int      `json:"premium_type"`
	PublicFlags   *int      `json:"public_flags"`
}

type VerificationLevel int

type VoiceChannel struct {
	GuildChannel
}

type VoiceState struct {
	GuildID    *Snowflake `json:"guild_id,omitempty"`
	ChannelID  *Snowflake `json:"channel_id"`
	UserID     Snowflake  `json:"user_id"`
	Member     *Member    `json:"member,omitempty"`
	SessionID  string     `json:"session_id"`
	Deaf       bool       `json:"deaf"`
	Mute       bool       `json:"mute"`
	SelfDeaf   bool       `json:"self_deaf"`
	SelfMute   bool       `json:"self_mute"`
	SelfStream *bool      `json:"self_stream,omitempty"`
	SelfVideo  bool       `json:"self_video"`
	Suppress   bool       `json:"suppress"`
}

type WebhookEventHandler interface {
	EventHandler
	Handle(Disgo, EventManager, chan interface{}, interface{})
}

type WebhookServer interface {
	Disgo() Disgo
	PublicKey() ed25519.PublicKey
	ListenURL() string
	Router() *mux.Router
	Start() error
	Close()
}