eventhandlers.go

// Code generated by \"eventhandlers\"; DO NOT EDIT
// See events.go

package guildrone

// Following are all the event types.
// Event type values are used to match the events returned by Guilded.
// EventTypes surrounded by __ are synthetic and are internal to Guildrone.
const (
	calendarEventCreatedEventType          = "CalendarEventCreated"
	calendarEventDeletedEventType          = "CalendarEventDeleted"
	calendarEventRsvpDeletedEventType      = "CalendarEventRsvpDeleted"
	calendarEventRsvpManyUpdatedEventType  = "CalendarEventRsvpManyUpdated"
	calendarEventRsvpUpdatedEventType      = "CalendarEventRsvpUpdated"
	calendarEventUpdatedEventType          = "CalendarEventUpdated"
	channelMessageReactionCreatedEventType = "ChannelMessageReactionCreated"
	channelMessageReactionDeletedEventType = "ChannelMessageReactionDeleted"
	chatMessageCreatedEventType            = "ChatMessageCreated"
	chatMessageDeletedEventType            = "ChatMessageDeleted"
	chatMessageUpdatedEventType            = "ChatMessageUpdated"
	connectEventType                       = "__Connect__"
	disconnectEventType                    = "__Disconnect__"
	docCreatedEventType                    = "DocCreated"
	docDeletedEventType                    = "DocDeleted"
	docUpdatedEventType                    = "DocUpdated"
	eventEventType                         = "__Event__"
	forumTopicCreatedEventType             = "ForumTopicCreated"
	forumTopicDeletedEventType             = "ForumTopicDeleted"
	forumTopicUpdatedEventType             = "ForumTopicUpdated"
	listItemCompletedEventType             = "ListItemCompleted"
	listItemCreatedEventType               = "ListItemCreated"
	listItemDeletedEventType               = "ListItemDeleted"
	listItemUpdatedEventType               = "ListItemUpdated"
	rateLimitEventType                     = "__RateLimit__"
	readyEventType                         = "Ready"
	resumeEventType                        = "__Resume__"
	teamChannelCreatedEventType            = "TeamChannelCreated"
	teamChannelUpdatedEventType            = "TeamChannelUpdated"
	teamMemberBannedEventType              = "TeamMemberBanned"
	teamMemberJoinedEventType              = "TeamMemberJoined"
	teamMemberRemovedEventType             = "TeamMemberRemoved"
	teamMemberUnbannedEventType            = "TeamMemberUnbanned"
	teamMemberUpdatedEventType             = "TeamMemberUpdated"
	teamRolesUpdatedEventType              = "TeamRolesUpdated"
	teamWebhookCreatedEventType            = "TeamWebhookCreated"
	teamWebhookUpdatedEventType            = "TeamWebhookUpdated"
)

// calendarEventCreatedEventHandler is an event handler for CalendarEventCreated events.
type calendarEventCreatedEventHandler func(*Session, *CalendarEventCreated)

// Type returns the event type for CalendarEventCreated events.
func (eh calendarEventCreatedEventHandler) Type() string {
	return calendarEventCreatedEventType
}

// New returns a new instance of CalendarEventCreated.
func (eh calendarEventCreatedEventHandler) New() interface{} {
	return &CalendarEventCreated{}
}

// Handle is the handler for CalendarEventCreated events.
func (eh calendarEventCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*CalendarEventCreated); ok {
		eh(s, t)
	}
}

// calendarEventDeletedEventHandler is an event handler for CalendarEventDeleted events.
type calendarEventDeletedEventHandler func(*Session, *CalendarEventDeleted)

// Type returns the event type for CalendarEventDeleted events.
func (eh calendarEventDeletedEventHandler) Type() string {
	return calendarEventDeletedEventType
}

// New returns a new instance of CalendarEventDeleted.
func (eh calendarEventDeletedEventHandler) New() interface{} {
	return &CalendarEventDeleted{}
}

// Handle is the handler for CalendarEventDeleted events.
func (eh calendarEventDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*CalendarEventDeleted); ok {
		eh(s, t)
	}
}

// calendarEventRsvpDeletedEventHandler is an event handler for CalendarEventRsvpDeleted events.
type calendarEventRsvpDeletedEventHandler func(*Session, *CalendarEventRsvpDeleted)

// Type returns the event type for CalendarEventRsvpDeleted events.
func (eh calendarEventRsvpDeletedEventHandler) Type() string {
	return calendarEventRsvpDeletedEventType
}

// New returns a new instance of CalendarEventRsvpDeleted.
func (eh calendarEventRsvpDeletedEventHandler) New() interface{} {
	return &CalendarEventRsvpDeleted{}
}

// Handle is the handler for CalendarEventRsvpDeleted events.
func (eh calendarEventRsvpDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*CalendarEventRsvpDeleted); ok {
		eh(s, t)
	}
}

// calendarEventRsvpManyUpdatedEventHandler is an event handler for CalendarEventRsvpManyUpdated events.
type calendarEventRsvpManyUpdatedEventHandler func(*Session, *CalendarEventRsvpManyUpdated)

// Type returns the event type for CalendarEventRsvpManyUpdated events.
func (eh calendarEventRsvpManyUpdatedEventHandler) Type() string {
	return calendarEventRsvpManyUpdatedEventType
}

// New returns a new instance of CalendarEventRsvpManyUpdated.
func (eh calendarEventRsvpManyUpdatedEventHandler) New() interface{} {
	return &CalendarEventRsvpManyUpdated{}
}

// Handle is the handler for CalendarEventRsvpManyUpdated events.
func (eh calendarEventRsvpManyUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*CalendarEventRsvpManyUpdated); ok {
		eh(s, t)
	}
}

// calendarEventRsvpUpdatedEventHandler is an event handler for CalendarEventRsvpUpdated events.
type calendarEventRsvpUpdatedEventHandler func(*Session, *CalendarEventRsvpUpdated)

// Type returns the event type for CalendarEventRsvpUpdated events.
func (eh calendarEventRsvpUpdatedEventHandler) Type() string {
	return calendarEventRsvpUpdatedEventType
}

// New returns a new instance of CalendarEventRsvpUpdated.
func (eh calendarEventRsvpUpdatedEventHandler) New() interface{} {
	return &CalendarEventRsvpUpdated{}
}

// Handle is the handler for CalendarEventRsvpUpdated events.
func (eh calendarEventRsvpUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*CalendarEventRsvpUpdated); ok {
		eh(s, t)
	}
}

// calendarEventUpdatedEventHandler is an event handler for CalendarEventUpdated events.
type calendarEventUpdatedEventHandler func(*Session, *CalendarEventUpdated)

// Type returns the event type for CalendarEventUpdated events.
func (eh calendarEventUpdatedEventHandler) Type() string {
	return calendarEventUpdatedEventType
}

// New returns a new instance of CalendarEventUpdated.
func (eh calendarEventUpdatedEventHandler) New() interface{} {
	return &CalendarEventUpdated{}
}

// Handle is the handler for CalendarEventUpdated events.
func (eh calendarEventUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*CalendarEventUpdated); ok {
		eh(s, t)
	}
}

// channelMessageReactionCreatedEventHandler is an event handler for ChannelMessageReactionCreated events.
type channelMessageReactionCreatedEventHandler func(*Session, *ChannelMessageReactionCreated)

// Type returns the event type for ChannelMessageReactionCreated events.
func (eh channelMessageReactionCreatedEventHandler) Type() string {
	return channelMessageReactionCreatedEventType
}

// New returns a new instance of ChannelMessageReactionCreated.
func (eh channelMessageReactionCreatedEventHandler) New() interface{} {
	return &ChannelMessageReactionCreated{}
}

// Handle is the handler for ChannelMessageReactionCreated events.
func (eh channelMessageReactionCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChannelMessageReactionCreated); ok {
		eh(s, t)
	}
}

// channelMessageReactionDeletedEventHandler is an event handler for ChannelMessageReactionDeleted events.
type channelMessageReactionDeletedEventHandler func(*Session, *ChannelMessageReactionDeleted)

// Type returns the event type for ChannelMessageReactionDeleted events.
func (eh channelMessageReactionDeletedEventHandler) Type() string {
	return channelMessageReactionDeletedEventType
}

// New returns a new instance of ChannelMessageReactionDeleted.
func (eh channelMessageReactionDeletedEventHandler) New() interface{} {
	return &ChannelMessageReactionDeleted{}
}

// Handle is the handler for ChannelMessageReactionDeleted events.
func (eh channelMessageReactionDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChannelMessageReactionDeleted); ok {
		eh(s, t)
	}
}

// chatMessageCreatedEventHandler is an event handler for ChatMessageCreated events.
type chatMessageCreatedEventHandler func(*Session, *ChatMessageCreated)

// Type returns the event type for ChatMessageCreated events.
func (eh chatMessageCreatedEventHandler) Type() string {
	return chatMessageCreatedEventType
}

// New returns a new instance of ChatMessageCreated.
func (eh chatMessageCreatedEventHandler) New() interface{} {
	return &ChatMessageCreated{}
}

// Handle is the handler for ChatMessageCreated events.
func (eh chatMessageCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChatMessageCreated); ok {
		eh(s, t)
	}
}

// chatMessageDeletedEventHandler is an event handler for ChatMessageDeleted events.
type chatMessageDeletedEventHandler func(*Session, *ChatMessageDeleted)

// Type returns the event type for ChatMessageDeleted events.
func (eh chatMessageDeletedEventHandler) Type() string {
	return chatMessageDeletedEventType
}

// New returns a new instance of ChatMessageDeleted.
func (eh chatMessageDeletedEventHandler) New() interface{} {
	return &ChatMessageDeleted{}
}

// Handle is the handler for ChatMessageDeleted events.
func (eh chatMessageDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChatMessageDeleted); ok {
		eh(s, t)
	}
}

// chatMessageUpdatedEventHandler is an event handler for ChatMessageUpdated events.
type chatMessageUpdatedEventHandler func(*Session, *ChatMessageUpdated)

// Type returns the event type for ChatMessageUpdated events.
func (eh chatMessageUpdatedEventHandler) Type() string {
	return chatMessageUpdatedEventType
}

// New returns a new instance of ChatMessageUpdated.
func (eh chatMessageUpdatedEventHandler) New() interface{} {
	return &ChatMessageUpdated{}
}

// Handle is the handler for ChatMessageUpdated events.
func (eh chatMessageUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ChatMessageUpdated); ok {
		eh(s, t)
	}
}

// connectEventHandler is an event handler for Connect events.
type connectEventHandler func(*Session, *Connect)

// Type returns the event type for Connect events.
func (eh connectEventHandler) Type() string {
	return connectEventType
}

// Handle is the handler for Connect events.
func (eh connectEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Connect); ok {
		eh(s, t)
	}
}

// disconnectEventHandler is an event handler for Disconnect events.
type disconnectEventHandler func(*Session, *Disconnect)

// Type returns the event type for Disconnect events.
func (eh disconnectEventHandler) Type() string {
	return disconnectEventType
}

// Handle is the handler for Disconnect events.
func (eh disconnectEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Disconnect); ok {
		eh(s, t)
	}
}

// docCreatedEventHandler is an event handler for DocCreated events.
type docCreatedEventHandler func(*Session, *DocCreated)

// Type returns the event type for DocCreated events.
func (eh docCreatedEventHandler) Type() string {
	return docCreatedEventType
}

// New returns a new instance of DocCreated.
func (eh docCreatedEventHandler) New() interface{} {
	return &DocCreated{}
}

// Handle is the handler for DocCreated events.
func (eh docCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*DocCreated); ok {
		eh(s, t)
	}
}

// docDeletedEventHandler is an event handler for DocDeleted events.
type docDeletedEventHandler func(*Session, *DocDeleted)

// Type returns the event type for DocDeleted events.
func (eh docDeletedEventHandler) Type() string {
	return docDeletedEventType
}

// New returns a new instance of DocDeleted.
func (eh docDeletedEventHandler) New() interface{} {
	return &DocDeleted{}
}

// Handle is the handler for DocDeleted events.
func (eh docDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*DocDeleted); ok {
		eh(s, t)
	}
}

// docUpdatedEventHandler is an event handler for DocUpdated events.
type docUpdatedEventHandler func(*Session, *DocUpdated)

// Type returns the event type for DocUpdated events.
func (eh docUpdatedEventHandler) Type() string {
	return docUpdatedEventType
}

// New returns a new instance of DocUpdated.
func (eh docUpdatedEventHandler) New() interface{} {
	return &DocUpdated{}
}

// Handle is the handler for DocUpdated events.
func (eh docUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*DocUpdated); ok {
		eh(s, t)
	}
}

// eventEventHandler is an event handler for Event events.
type eventEventHandler func(*Session, *Event)

// Type returns the event type for Event events.
func (eh eventEventHandler) Type() string {
	return eventEventType
}

// Handle is the handler for Event events.
func (eh eventEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Event); ok {
		eh(s, t)
	}
}

// forumTopicCreatedEventHandler is an event handler for ForumTopicCreated events.
type forumTopicCreatedEventHandler func(*Session, *ForumTopicCreated)

// Type returns the event type for ForumTopicCreated events.
func (eh forumTopicCreatedEventHandler) Type() string {
	return forumTopicCreatedEventType
}

// New returns a new instance of ForumTopicCreated.
func (eh forumTopicCreatedEventHandler) New() interface{} {
	return &ForumTopicCreated{}
}

// Handle is the handler for ForumTopicCreated events.
func (eh forumTopicCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ForumTopicCreated); ok {
		eh(s, t)
	}
}

// forumTopicDeletedEventHandler is an event handler for ForumTopicDeleted events.
type forumTopicDeletedEventHandler func(*Session, *ForumTopicDeleted)

// Type returns the event type for ForumTopicDeleted events.
func (eh forumTopicDeletedEventHandler) Type() string {
	return forumTopicDeletedEventType
}

// New returns a new instance of ForumTopicDeleted.
func (eh forumTopicDeletedEventHandler) New() interface{} {
	return &ForumTopicDeleted{}
}

// Handle is the handler for ForumTopicDeleted events.
func (eh forumTopicDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ForumTopicDeleted); ok {
		eh(s, t)
	}
}

// forumTopicUpdatedEventHandler is an event handler for ForumTopicUpdated events.
type forumTopicUpdatedEventHandler func(*Session, *ForumTopicUpdated)

// Type returns the event type for ForumTopicUpdated events.
func (eh forumTopicUpdatedEventHandler) Type() string {
	return forumTopicUpdatedEventType
}

// New returns a new instance of ForumTopicUpdated.
func (eh forumTopicUpdatedEventHandler) New() interface{} {
	return &ForumTopicUpdated{}
}

// Handle is the handler for ForumTopicUpdated events.
func (eh forumTopicUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ForumTopicUpdated); ok {
		eh(s, t)
	}
}

// listItemCompletedEventHandler is an event handler for ListItemCompleted events.
type listItemCompletedEventHandler func(*Session, *ListItemCompleted)

// Type returns the event type for ListItemCompleted events.
func (eh listItemCompletedEventHandler) Type() string {
	return listItemCompletedEventType
}

// New returns a new instance of ListItemCompleted.
func (eh listItemCompletedEventHandler) New() interface{} {
	return &ListItemCompleted{}
}

// Handle is the handler for ListItemCompleted events.
func (eh listItemCompletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ListItemCompleted); ok {
		eh(s, t)
	}
}

// listItemCreatedEventHandler is an event handler for ListItemCreated events.
type listItemCreatedEventHandler func(*Session, *ListItemCreated)

// Type returns the event type for ListItemCreated events.
func (eh listItemCreatedEventHandler) Type() string {
	return listItemCreatedEventType
}

// New returns a new instance of ListItemCreated.
func (eh listItemCreatedEventHandler) New() interface{} {
	return &ListItemCreated{}
}

// Handle is the handler for ListItemCreated events.
func (eh listItemCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ListItemCreated); ok {
		eh(s, t)
	}
}

// listItemDeletedEventHandler is an event handler for ListItemDeleted events.
type listItemDeletedEventHandler func(*Session, *ListItemDeleted)

// Type returns the event type for ListItemDeleted events.
func (eh listItemDeletedEventHandler) Type() string {
	return listItemDeletedEventType
}

// New returns a new instance of ListItemDeleted.
func (eh listItemDeletedEventHandler) New() interface{} {
	return &ListItemDeleted{}
}

// Handle is the handler for ListItemDeleted events.
func (eh listItemDeletedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ListItemDeleted); ok {
		eh(s, t)
	}
}

// listItemUpdatedEventHandler is an event handler for ListItemUpdated events.
type listItemUpdatedEventHandler func(*Session, *ListItemUpdated)

// Type returns the event type for ListItemUpdated events.
func (eh listItemUpdatedEventHandler) Type() string {
	return listItemUpdatedEventType
}

// New returns a new instance of ListItemUpdated.
func (eh listItemUpdatedEventHandler) New() interface{} {
	return &ListItemUpdated{}
}

// Handle is the handler for ListItemUpdated events.
func (eh listItemUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*ListItemUpdated); ok {
		eh(s, t)
	}
}

// rateLimitEventHandler is an event handler for RateLimit events.
type rateLimitEventHandler func(*Session, *RateLimit)

// Type returns the event type for RateLimit events.
func (eh rateLimitEventHandler) Type() string {
	return rateLimitEventType
}

// Handle is the handler for RateLimit events.
func (eh rateLimitEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*RateLimit); ok {
		eh(s, t)
	}
}

// readyEventHandler is an event handler for Ready events.
type readyEventHandler func(*Session, *Ready)

// Type returns the event type for Ready events.
func (eh readyEventHandler) Type() string {
	return readyEventType
}

// New returns a new instance of Ready.
func (eh readyEventHandler) New() interface{} {
	return &Ready{}
}

// Handle is the handler for Ready events.
func (eh readyEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Ready); ok {
		eh(s, t)
	}
}

// resumeEventHandler is an event handler for Resume events.
type resumeEventHandler func(*Session, *Resume)

// Type returns the event type for Resume events.
func (eh resumeEventHandler) Type() string {
	return resumeEventType
}

// Handle is the handler for Resume events.
func (eh resumeEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*Resume); ok {
		eh(s, t)
	}
}

// teamChannelCreatedEventHandler is an event handler for TeamChannelCreated events.
type teamChannelCreatedEventHandler func(*Session, *TeamChannelCreated)

// Type returns the event type for TeamChannelCreated events.
func (eh teamChannelCreatedEventHandler) Type() string {
	return teamChannelCreatedEventType
}

// New returns a new instance of TeamChannelCreated.
func (eh teamChannelCreatedEventHandler) New() interface{} {
	return &TeamChannelCreated{}
}

// Handle is the handler for TeamChannelCreated events.
func (eh teamChannelCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamChannelCreated); ok {
		eh(s, t)
	}
}

// teamChannelUpdatedEventHandler is an event handler for TeamChannelUpdated events.
type teamChannelUpdatedEventHandler func(*Session, *TeamChannelUpdated)

// Type returns the event type for TeamChannelUpdated events.
func (eh teamChannelUpdatedEventHandler) Type() string {
	return teamChannelUpdatedEventType
}

// New returns a new instance of TeamChannelUpdated.
func (eh teamChannelUpdatedEventHandler) New() interface{} {
	return &TeamChannelUpdated{}
}

// Handle is the handler for TeamChannelUpdated events.
func (eh teamChannelUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamChannelUpdated); ok {
		eh(s, t)
	}
}

// teamMemberBannedEventHandler is an event handler for TeamMemberBanned events.
type teamMemberBannedEventHandler func(*Session, *TeamMemberBanned)

// Type returns the event type for TeamMemberBanned events.
func (eh teamMemberBannedEventHandler) Type() string {
	return teamMemberBannedEventType
}

// New returns a new instance of TeamMemberBanned.
func (eh teamMemberBannedEventHandler) New() interface{} {
	return &TeamMemberBanned{}
}

// Handle is the handler for TeamMemberBanned events.
func (eh teamMemberBannedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamMemberBanned); ok {
		eh(s, t)
	}
}

// teamMemberJoinedEventHandler is an event handler for TeamMemberJoined events.
type teamMemberJoinedEventHandler func(*Session, *TeamMemberJoined)

// Type returns the event type for TeamMemberJoined events.
func (eh teamMemberJoinedEventHandler) Type() string {
	return teamMemberJoinedEventType
}

// New returns a new instance of TeamMemberJoined.
func (eh teamMemberJoinedEventHandler) New() interface{} {
	return &TeamMemberJoined{}
}

// Handle is the handler for TeamMemberJoined events.
func (eh teamMemberJoinedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamMemberJoined); ok {
		eh(s, t)
	}
}

// teamMemberRemovedEventHandler is an event handler for TeamMemberRemoved events.
type teamMemberRemovedEventHandler func(*Session, *TeamMemberRemoved)

// Type returns the event type for TeamMemberRemoved events.
func (eh teamMemberRemovedEventHandler) Type() string {
	return teamMemberRemovedEventType
}

// New returns a new instance of TeamMemberRemoved.
func (eh teamMemberRemovedEventHandler) New() interface{} {
	return &TeamMemberRemoved{}
}

// Handle is the handler for TeamMemberRemoved events.
func (eh teamMemberRemovedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamMemberRemoved); ok {
		eh(s, t)
	}
}

// teamMemberUnbannedEventHandler is an event handler for TeamMemberUnbanned events.
type teamMemberUnbannedEventHandler func(*Session, *TeamMemberUnbanned)

// Type returns the event type for TeamMemberUnbanned events.
func (eh teamMemberUnbannedEventHandler) Type() string {
	return teamMemberUnbannedEventType
}

// New returns a new instance of TeamMemberUnbanned.
func (eh teamMemberUnbannedEventHandler) New() interface{} {
	return &TeamMemberUnbanned{}
}

// Handle is the handler for TeamMemberUnbanned events.
func (eh teamMemberUnbannedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamMemberUnbanned); ok {
		eh(s, t)
	}
}

// teamMemberUpdatedEventHandler is an event handler for TeamMemberUpdated events.
type teamMemberUpdatedEventHandler func(*Session, *TeamMemberUpdated)

// Type returns the event type for TeamMemberUpdated events.
func (eh teamMemberUpdatedEventHandler) Type() string {
	return teamMemberUpdatedEventType
}

// New returns a new instance of TeamMemberUpdated.
func (eh teamMemberUpdatedEventHandler) New() interface{} {
	return &TeamMemberUpdated{}
}

// Handle is the handler for TeamMemberUpdated events.
func (eh teamMemberUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamMemberUpdated); ok {
		eh(s, t)
	}
}

// teamRolesUpdatedEventHandler is an event handler for TeamRolesUpdated events.
type teamRolesUpdatedEventHandler func(*Session, *TeamRolesUpdated)

// Type returns the event type for TeamRolesUpdated events.
func (eh teamRolesUpdatedEventHandler) Type() string {
	return teamRolesUpdatedEventType
}

// New returns a new instance of TeamRolesUpdated.
func (eh teamRolesUpdatedEventHandler) New() interface{} {
	return &TeamRolesUpdated{}
}

// Handle is the handler for TeamRolesUpdated events.
func (eh teamRolesUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamRolesUpdated); ok {
		eh(s, t)
	}
}

// teamWebhookCreatedEventHandler is an event handler for TeamWebhookCreated events.
type teamWebhookCreatedEventHandler func(*Session, *TeamWebhookCreated)

// Type returns the event type for TeamWebhookCreated events.
func (eh teamWebhookCreatedEventHandler) Type() string {
	return teamWebhookCreatedEventType
}

// New returns a new instance of TeamWebhookCreated.
func (eh teamWebhookCreatedEventHandler) New() interface{} {
	return &TeamWebhookCreated{}
}

// Handle is the handler for TeamWebhookCreated events.
func (eh teamWebhookCreatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamWebhookCreated); ok {
		eh(s, t)
	}
}

// teamWebhookUpdatedEventHandler is an event handler for TeamWebhookUpdated events.
type teamWebhookUpdatedEventHandler func(*Session, *TeamWebhookUpdated)

// Type returns the event type for TeamWebhookUpdated events.
func (eh teamWebhookUpdatedEventHandler) Type() string {
	return teamWebhookUpdatedEventType
}

// New returns a new instance of TeamWebhookUpdated.
func (eh teamWebhookUpdatedEventHandler) New() interface{} {
	return &TeamWebhookUpdated{}
}

// Handle is the handler for TeamWebhookUpdated events.
func (eh teamWebhookUpdatedEventHandler) Handle(s *Session, i interface{}) {
	if t, ok := i.(*TeamWebhookUpdated); ok {
		eh(s, t)
	}
}

func handlerForInterface(handler interface{}) EventHandler {
	switch v := handler.(type) {
	case func(*Session, interface{}):
		return interfaceEventHandler(v)
	case func(*Session, *CalendarEventCreated):
		return calendarEventCreatedEventHandler(v)
	case func(*Session, *CalendarEventDeleted):
		return calendarEventDeletedEventHandler(v)
	case func(*Session, *CalendarEventRsvpDeleted):
		return calendarEventRsvpDeletedEventHandler(v)
	case func(*Session, *CalendarEventRsvpManyUpdated):
		return calendarEventRsvpManyUpdatedEventHandler(v)
	case func(*Session, *CalendarEventRsvpUpdated):
		return calendarEventRsvpUpdatedEventHandler(v)
	case func(*Session, *CalendarEventUpdated):
		return calendarEventUpdatedEventHandler(v)
	case func(*Session, *ChannelMessageReactionCreated):
		return channelMessageReactionCreatedEventHandler(v)
	case func(*Session, *ChannelMessageReactionDeleted):
		return channelMessageReactionDeletedEventHandler(v)
	case func(*Session, *ChatMessageCreated):
		return chatMessageCreatedEventHandler(v)
	case func(*Session, *ChatMessageDeleted):
		return chatMessageDeletedEventHandler(v)
	case func(*Session, *ChatMessageUpdated):
		return chatMessageUpdatedEventHandler(v)
	case func(*Session, *Connect):
		return connectEventHandler(v)
	case func(*Session, *Disconnect):
		return disconnectEventHandler(v)
	case func(*Session, *DocCreated):
		return docCreatedEventHandler(v)
	case func(*Session, *DocDeleted):
		return docDeletedEventHandler(v)
	case func(*Session, *DocUpdated):
		return docUpdatedEventHandler(v)
	case func(*Session, *Event):
		return eventEventHandler(v)
	case func(*Session, *ForumTopicCreated):
		return forumTopicCreatedEventHandler(v)
	case func(*Session, *ForumTopicDeleted):
		return forumTopicDeletedEventHandler(v)
	case func(*Session, *ForumTopicUpdated):
		return forumTopicUpdatedEventHandler(v)
	case func(*Session, *ListItemCompleted):
		return listItemCompletedEventHandler(v)
	case func(*Session, *ListItemCreated):
		return listItemCreatedEventHandler(v)
	case func(*Session, *ListItemDeleted):
		return listItemDeletedEventHandler(v)
	case func(*Session, *ListItemUpdated):
		return listItemUpdatedEventHandler(v)
	case func(*Session, *RateLimit):
		return rateLimitEventHandler(v)
	case func(*Session, *Ready):
		return readyEventHandler(v)
	case func(*Session, *Resume):
		return resumeEventHandler(v)
	case func(*Session, *TeamChannelCreated):
		return teamChannelCreatedEventHandler(v)
	case func(*Session, *TeamChannelUpdated):
		return teamChannelUpdatedEventHandler(v)
	case func(*Session, *TeamMemberBanned):
		return teamMemberBannedEventHandler(v)
	case func(*Session, *TeamMemberJoined):
		return teamMemberJoinedEventHandler(v)
	case func(*Session, *TeamMemberRemoved):
		return teamMemberRemovedEventHandler(v)
	case func(*Session, *TeamMemberUnbanned):
		return teamMemberUnbannedEventHandler(v)
	case func(*Session, *TeamMemberUpdated):
		return teamMemberUpdatedEventHandler(v)
	case func(*Session, *TeamRolesUpdated):
		return teamRolesUpdatedEventHandler(v)
	case func(*Session, *TeamWebhookCreated):
		return teamWebhookCreatedEventHandler(v)
	case func(*Session, *TeamWebhookUpdated):
		return teamWebhookUpdatedEventHandler(v)
	}

	return nil
}

func init() {
	registerInterfaceProvider(calendarEventCreatedEventHandler(nil))
	registerInterfaceProvider(calendarEventDeletedEventHandler(nil))
	registerInterfaceProvider(calendarEventRsvpDeletedEventHandler(nil))
	registerInterfaceProvider(calendarEventRsvpManyUpdatedEventHandler(nil))
	registerInterfaceProvider(calendarEventRsvpUpdatedEventHandler(nil))
	registerInterfaceProvider(calendarEventUpdatedEventHandler(nil))
	registerInterfaceProvider(channelMessageReactionCreatedEventHandler(nil))
	registerInterfaceProvider(channelMessageReactionDeletedEventHandler(nil))
	registerInterfaceProvider(chatMessageCreatedEventHandler(nil))
	registerInterfaceProvider(chatMessageDeletedEventHandler(nil))
	registerInterfaceProvider(chatMessageUpdatedEventHandler(nil))
	registerInterfaceProvider(docCreatedEventHandler(nil))
	registerInterfaceProvider(docDeletedEventHandler(nil))
	registerInterfaceProvider(docUpdatedEventHandler(nil))
	registerInterfaceProvider(forumTopicCreatedEventHandler(nil))
	registerInterfaceProvider(forumTopicDeletedEventHandler(nil))
	registerInterfaceProvider(forumTopicUpdatedEventHandler(nil))
	registerInterfaceProvider(listItemCompletedEventHandler(nil))
	registerInterfaceProvider(listItemCreatedEventHandler(nil))
	registerInterfaceProvider(listItemDeletedEventHandler(nil))
	registerInterfaceProvider(listItemUpdatedEventHandler(nil))
	registerInterfaceProvider(readyEventHandler(nil))
	registerInterfaceProvider(teamChannelCreatedEventHandler(nil))
	registerInterfaceProvider(teamChannelUpdatedEventHandler(nil))
	registerInterfaceProvider(teamMemberBannedEventHandler(nil))
	registerInterfaceProvider(teamMemberJoinedEventHandler(nil))
	registerInterfaceProvider(teamMemberRemovedEventHandler(nil))
	registerInterfaceProvider(teamMemberUnbannedEventHandler(nil))
	registerInterfaceProvider(teamMemberUpdatedEventHandler(nil))
	registerInterfaceProvider(teamRolesUpdatedEventHandler(nil))
	registerInterfaceProvider(teamWebhookCreatedEventHandler(nil))
	registerInterfaceProvider(teamWebhookUpdatedEventHandler(nil))
}