func (eh presencesReplaceEventHandler) New() interface{} {
	return &PresencesReplace{}
}
New returns a new instance of PresencesReplace.
package discordgo
const (
	channelCreateEventType            = "CHANNEL_CREATE"
	channelDeleteEventType            = "CHANNEL_DELETE"
	channelPinsUpdateEventType        = "CHANNEL_PINS_UPDATE"
	channelUpdateEventType            = "CHANNEL_UPDATE"
	connectEventType                  = "__CONNECT__"
	disconnectEventType               = "__DISCONNECT__"
	eventEventType                    = "__EVENT__"
	guildBanAddEventType              = "GUILD_BAN_ADD"
	guildBanRemoveEventType           = "GUILD_BAN_REMOVE"
	guildCreateEventType              = "GUILD_CREATE"
	guildDeleteEventType              = "GUILD_DELETE"
	guildEmojisUpdateEventType        = "GUILD_EMOJIS_UPDATE"
	guildIntegrationsUpdateEventType  = "GUILD_INTEGRATIONS_UPDATE"
	guildMemberAddEventType           = "GUILD_MEMBER_ADD"
	guildMemberRemoveEventType        = "GUILD_MEMBER_REMOVE"
	guildMemberUpdateEventType        = "GUILD_MEMBER_UPDATE"
	guildMembersChunkEventType        = "GUILD_MEMBERS_CHUNK"
	guildRoleCreateEventType          = "GUILD_ROLE_CREATE"
	guildRoleDeleteEventType          = "GUILD_ROLE_DELETE"
	guildRoleUpdateEventType          = "GUILD_ROLE_UPDATE"
	guildUpdateEventType              = "GUILD_UPDATE"
	messageAckEventType               = "MESSAGE_ACK"
	messageCreateEventType            = "MESSAGE_CREATE"
	messageDeleteEventType            = "MESSAGE_DELETE"
	messageDeleteBulkEventType        = "MESSAGE_DELETE_BULK"
	messageReactionAddEventType       = "MESSAGE_REACTION_ADD"
	messageReactionRemoveEventType    = "MESSAGE_REACTION_REMOVE"
	messageReactionRemoveAllEventType = "MESSAGE_REACTION_REMOVE_ALL"
	messageUpdateEventType            = "MESSAGE_UPDATE"
	presenceUpdateEventType           = "PRESENCE_UPDATE"
	presencesReplaceEventType         = "PRESENCES_REPLACE"
	rateLimitEventType                = "__RATE_LIMIT__"
	readyEventType                    = "READY"
	relationshipAddEventType          = "RELATIONSHIP_ADD"
	relationshipRemoveEventType       = "RELATIONSHIP_REMOVE"
	resumedEventType                  = "RESUMED"
	typingStartEventType              = "TYPING_START"
	userGuildSettingsUpdateEventType  = "USER_GUILD_SETTINGS_UPDATE"
	userNoteUpdateEventType           = "USER_NOTE_UPDATE"
	userSettingsUpdateEventType       = "USER_SETTINGS_UPDATE"
	userUpdateEventType               = "USER_UPDATE"
	voiceServerUpdateEventType        = "VOICE_SERVER_UPDATE"
	voiceStateUpdateEventType         = "VOICE_STATE_UPDATE"
	webhooksUpdateEventType           = "WEBHOOKS_UPDATE"
)
type channelCreateEventHandler func(*Session, *ChannelCreate)
func (eh channelCreateEventHandler) Type() string {
	return channelCreateEventType
}
func (eh channelCreateEventHandler) New() interface{} {
	return &ChannelCreate{}
}
func (eh channelCreateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChannelCreate); ok {
		eh(s, t)
	}
}
type channelDeleteEventHandler func(*Session, *ChannelDelete)
func (eh channelDeleteEventHandler) Type() string {
	return channelDeleteEventType
}
func (eh channelDeleteEventHandler) New() interface{} {
	return &ChannelDelete{}
}
func (eh channelDeleteEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChannelDelete); ok {
		eh(s, t)
	}
}
type channelPinsUpdateEventHandler func(*Session, *ChannelPinsUpdate)
func (eh channelPinsUpdateEventHandler) Type() string {
	return channelPinsUpdateEventType
}
func (eh channelPinsUpdateEventHandler) New() interface{} {
	return &ChannelPinsUpdate{}
}
func (eh channelPinsUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChannelPinsUpdate); ok {
		eh(s, t)
	}
}
type channelUpdateEventHandler func(*Session, *ChannelUpdate)
func (eh channelUpdateEventHandler) Type() string {
	return channelUpdateEventType
}
func (eh channelUpdateEventHandler) New() interface{} {
	return &ChannelUpdate{}
}
func (eh channelUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChannelUpdate); ok {
		eh(s, t)
	}
}
type connectEventHandler func(*Session, *Connect)
func (eh connectEventHandler) Type() string {
	return connectEventType
}
func (eh connectEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Connect); ok {
		eh(s, t)
	}
}
type disconnectEventHandler func(*Session, *Disconnect)
func (eh disconnectEventHandler) Type() string {
	return disconnectEventType
}
func (eh disconnectEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Disconnect); ok {
		eh(s, t)
	}
}
type eventEventHandler func(*Session, *Event)
func (eh eventEventHandler) Type() string {
	return eventEventType
}
func (eh eventEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Event); ok {
		eh(s, t)
	}
}
type guildBanAddEventHandler func(*Session, *GuildBanAdd)
func (eh guildBanAddEventHandler) Type() string {
	return guildBanAddEventType
}
func (eh guildBanAddEventHandler) New() interface{} {
	return &GuildBanAdd{}
}
func (eh guildBanAddEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildBanAdd); ok {
		eh(s, t)
	}
}
type guildBanRemoveEventHandler func(*Session, *GuildBanRemove)
func (eh guildBanRemoveEventHandler) Type() string {
	return guildBanRemoveEventType
}
func (eh guildBanRemoveEventHandler) New() interface{} {
	return &GuildBanRemove{}
}
func (eh guildBanRemoveEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildBanRemove); ok {
		eh(s, t)
	}
}
type guildCreateEventHandler func(*Session, *GuildCreate)
func (eh guildCreateEventHandler) Type() string {
	return guildCreateEventType
}
func (eh guildCreateEventHandler) New() interface{} {
	return &GuildCreate{}
}
func (eh guildCreateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildCreate); ok {
		eh(s, t)
	}
}
type guildDeleteEventHandler func(*Session, *GuildDelete)
func (eh guildDeleteEventHandler) Type() string {
	return guildDeleteEventType
}
func (eh guildDeleteEventHandler) New() interface{} {
	return &GuildDelete{}
}
func (eh guildDeleteEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildDelete); ok {
		eh(s, t)
	}
}
type guildEmojisUpdateEventHandler func(*Session, *GuildEmojisUpdate)
func (eh guildEmojisUpdateEventHandler) Type() string {
	return guildEmojisUpdateEventType
}
func (eh guildEmojisUpdateEventHandler) New() interface{} {
	return &GuildEmojisUpdate{}
}
func (eh guildEmojisUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildEmojisUpdate); ok {
		eh(s, t)
	}
}
type guildIntegrationsUpdateEventHandler func(*Session, *GuildIntegrationsUpdate)
func (eh guildIntegrationsUpdateEventHandler) Type() string {
	return guildIntegrationsUpdateEventType
}
func (eh guildIntegrationsUpdateEventHandler) New() interface{} {
	return &GuildIntegrationsUpdate{}
}
func (eh guildIntegrationsUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildIntegrationsUpdate); ok {
		eh(s, t)
	}
}
type guildMemberAddEventHandler func(*Session, *GuildMemberAdd)
func (eh guildMemberAddEventHandler) Type() string {
	return guildMemberAddEventType
}
func (eh guildMemberAddEventHandler) New() interface{} {
	return &GuildMemberAdd{}
}
func (eh guildMemberAddEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildMemberAdd); ok {
		eh(s, t)
	}
}
type guildMemberRemoveEventHandler func(*Session, *GuildMemberRemove)
func (eh guildMemberRemoveEventHandler) Type() string {
	return guildMemberRemoveEventType
}
func (eh guildMemberRemoveEventHandler) New() interface{} {
	return &GuildMemberRemove{}
}
func (eh guildMemberRemoveEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildMemberRemove); ok {
		eh(s, t)
	}
}
type guildMemberUpdateEventHandler func(*Session, *GuildMemberUpdate)
func (eh guildMemberUpdateEventHandler) Type() string {
	return guildMemberUpdateEventType
}
func (eh guildMemberUpdateEventHandler) New() interface{} {
	return &GuildMemberUpdate{}
}
func (eh guildMemberUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildMemberUpdate); ok {
		eh(s, t)
	}
}
type guildMembersChunkEventHandler func(*Session, *GuildMembersChunk)
func (eh guildMembersChunkEventHandler) Type() string {
	return guildMembersChunkEventType
}
func (eh guildMembersChunkEventHandler) New() interface{} {
	return &GuildMembersChunk{}
}
func (eh guildMembersChunkEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildMembersChunk); ok {
		eh(s, t)
	}
}
type guildRoleCreateEventHandler func(*Session, *GuildRoleCreate)
func (eh guildRoleCreateEventHandler) Type() string {
	return guildRoleCreateEventType
}
func (eh guildRoleCreateEventHandler) New() interface{} {
	return &GuildRoleCreate{}
}
func (eh guildRoleCreateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildRoleCreate); ok {
		eh(s, t)
	}
}
type guildRoleDeleteEventHandler func(*Session, *GuildRoleDelete)
func (eh guildRoleDeleteEventHandler) Type() string {
	return guildRoleDeleteEventType
}
func (eh guildRoleDeleteEventHandler) New() interface{} {
	return &GuildRoleDelete{}
}
func (eh guildRoleDeleteEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildRoleDelete); ok {
		eh(s, t)
	}
}
type guildRoleUpdateEventHandler func(*Session, *GuildRoleUpdate)
func (eh guildRoleUpdateEventHandler) Type() string {
	return guildRoleUpdateEventType
}
func (eh guildRoleUpdateEventHandler) New() interface{} {
	return &GuildRoleUpdate{}
}
func (eh guildRoleUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildRoleUpdate); ok {
		eh(s, t)
	}
}
type guildUpdateEventHandler func(*Session, *GuildUpdate)
func (eh guildUpdateEventHandler) Type() string {
	return guildUpdateEventType
}
func (eh guildUpdateEventHandler) New() interface{} {
	return &GuildUpdate{}
}
func (eh guildUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*GuildUpdate); ok {
		eh(s, t)
	}
}
type messageAckEventHandler func(*Session, *MessageAck)
func (eh messageAckEventHandler) Type() string {
	return messageAckEventType
}
func (eh messageAckEventHandler) New() interface{} {
	return &MessageAck{}
}
func (eh messageAckEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageAck); ok {
		eh(s, t)
	}
}
type messageCreateEventHandler func(*Session, *MessageCreate)
func (eh messageCreateEventHandler) Type() string {
	return messageCreateEventType
}
func (eh messageCreateEventHandler) New() interface{} {
	return &MessageCreate{}
}
func (eh messageCreateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageCreate); ok {
		eh(s, t)
	}
}
type messageDeleteEventHandler func(*Session, *MessageDelete)
func (eh messageDeleteEventHandler) Type() string {
	return messageDeleteEventType
}
func (eh messageDeleteEventHandler) New() interface{} {
	return &MessageDelete{}
}
func (eh messageDeleteEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageDelete); ok {
		eh(s, t)
	}
}
type messageDeleteBulkEventHandler func(*Session, *MessageDeleteBulk)
func (eh messageDeleteBulkEventHandler) Type() string {
	return messageDeleteBulkEventType
}
func (eh messageDeleteBulkEventHandler) New() interface{} {
	return &MessageDeleteBulk{}
}
func (eh messageDeleteBulkEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageDeleteBulk); ok {
		eh(s, t)
	}
}
type messageReactionAddEventHandler func(*Session, *MessageReactionAdd)
func (eh messageReactionAddEventHandler) Type() string {
	return messageReactionAddEventType
}
func (eh messageReactionAddEventHandler) New() interface{} {
	return &MessageReactionAdd{}
}
func (eh messageReactionAddEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageReactionAdd); ok {
		eh(s, t)
	}
}
type messageReactionRemoveEventHandler func(*Session, *MessageReactionRemove)
func (eh messageReactionRemoveEventHandler) Type() string {
	return messageReactionRemoveEventType
}
func (eh messageReactionRemoveEventHandler) New() interface{} {
	return &MessageReactionRemove{}
}
func (eh messageReactionRemoveEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageReactionRemove); ok {
		eh(s, t)
	}
}
type messageReactionRemoveAllEventHandler func(*Session, *MessageReactionRemoveAll)
func (eh messageReactionRemoveAllEventHandler) Type() string {
	return messageReactionRemoveAllEventType
}
func (eh messageReactionRemoveAllEventHandler) New() interface{} {
	return &MessageReactionRemoveAll{}
}
func (eh messageReactionRemoveAllEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageReactionRemoveAll); ok {
		eh(s, t)
	}
}
type messageUpdateEventHandler func(*Session, *MessageUpdate)
func (eh messageUpdateEventHandler) Type() string {
	return messageUpdateEventType
}
func (eh messageUpdateEventHandler) New() interface{} {
	return &MessageUpdate{}
}
func (eh messageUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*MessageUpdate); ok {
		eh(s, t)
	}
}
type presenceUpdateEventHandler func(*Session, *PresenceUpdate)
func (eh presenceUpdateEventHandler) Type() string {
	return presenceUpdateEventType
}
func (eh presenceUpdateEventHandler) New() interface{} {
	return &PresenceUpdate{}
}
func (eh presenceUpdateEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*PresenceUpdate); ok {
		eh(s, t)
	}
}
type presencesReplaceEventHandler func(*Session, *PresencesReplace)
func (eh presencesReplaceEventHandler) Type() string {
	return presencesReplaceEventType
}