func (s *Slacker) GetUserInfo(user string) (*slack.User, error) {
	return s.client.GetUserInfo(user)
}
GetUserInfo retrieve complete user information
package slacker
import (
	"context"
	"errors"
	"fmt"
	"github.com/shomali11/proper"
	"github.com/slack-go/slack"
	"github.com/slack-go/slack/slackevents"
	"github.com/slack-go/slack/socketmode"
)
const (
	space               = " "
	dash                = "-"
	star                = "*"
	newLine             = "\n"
	invalidToken        = "invalid token"
	helpCommand         = "help"
	directChannelMarker = "D"
	userMentionFormat   = "<@%s>"
	codeMessageFormat   = "`%s`"
	boldMessageFormat   = "*%s*"
	italicMessageFormat = "_%s_"
	quoteMessageFormat  = ">_*Example:* %s_"
	authorizedUsersOnly = "Authorized users only"
	slackBotUser        = "USLACKBOT"
)
var (
	errUnauthorized = errors.New("you are not authorized to execute this command")
)
func NewClient(botToken, appToken string, options ...ClientOption) *Slacker {
	defaults := newClientDefaults(options...)
	api := slack.New(
		botToken,
		slack.OptionDebug(defaults.Debug),
		slack.OptionAppLevelToken(appToken),
	)
	smc := socketmode.New(
		api,
		socketmode.OptionDebug(defaults.Debug),
	)
	slacker := &Slacker{
		client:             api,
		socketModeClient:   smc,
		commandChannel:     make(chan *CommandEvent, 100),
		errUnauthorized:    errUnauthorized,
		botInteractionMode: defaults.BotMode,
	}
	return slacker
}
type Slacker struct {
	client                  *slack.Client
	socketModeClient        *socketmode.Client
	botCommands             []BotCommand
	botContextConstructor   func(ctx context.Context, api *slack.Client, client *socketmode.Client, evt *MessageEvent) BotContext
	requestConstructor      func(botCtx BotContext, properties *proper.Properties) Request
	responseConstructor     func(botCtx BotContext) ResponseWriter
	initHandler             func()
	errorHandler            func(err string)
	interactiveEventHandler func(*Slacker, *socketmode.Event, *slack.InteractionCallback)
	helpDefinition          *CommandDefinition
	defaultMessageHandler   func(botCtx BotContext, request Request, response ResponseWriter)
	defaultEventHandler     func(interface{})
	errUnauthorized         error
	commandChannel          chan *CommandEvent
	appID                   string
	botInteractionMode      BotInteractionMode
}
func (s *Slacker) BotCommands() []BotCommand {
	return s.botCommands
}
func (s *Slacker) Client() *slack.Client {
	return s.client
}
func (s *Slacker) SocketMode() *socketmode.Client {
	return s.socketModeClient
}
func (s *Slacker) Init(initHandler func()) {
	s.initHandler = initHandler
}
func (s *Slacker) Err(errorHandler func(err string)) {
	s.errorHandler = errorHandler
}
func (s *Slacker) Interactive(interactiveEventHandler func(*Slacker, *socketmode.Event, *slack.InteractionCallback)) {
	s.interactiveEventHandler = interactiveEventHandler
}
func (s *Slacker) CustomRequest(requestConstructor func(botCtx BotContext, properties *proper.Properties) Request) {
	s.requestConstructor = requestConstructor
}
func (s *Slacker) CustomResponse(responseConstructor func(botCtx BotContext) ResponseWriter) {
	s.responseConstructor = responseConstructor
}
func (s *Slacker) DefaultCommand(defaultMessageHandler func(botCtx BotContext, request Request, response ResponseWriter)) {
	s.defaultMessageHandler = defaultMessageHandler
}
func (s *Slacker) DefaultEvent(defaultEventHandler func(interface{})) {
	s.defaultEventHandler = defaultEventHandler
}
func (s *Slacker) UnAuthorizedError(errUnauthorized error) {
	s.errUnauthorized = errUnauthorized
}
func (s *Slacker) Help(definition *CommandDefinition) {
	s.helpDefinition = definition
}
func (s *Slacker) Command(usage string, definition *CommandDefinition) {
	s.botCommands = append(s.botCommands, NewBotCommand(usage, definition))
}
func (s *Slacker) CommandEvents() <-chan *CommandEvent {
	return s.commandChannel
}
func (s *Slacker) Listen(ctx context.Context) error {
	s.prependHelpHandle()
	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			case evt, ok := <-s.socketModeClient.Events:
				if !ok {
					return
				}
				switch evt.Type {
				case socketmode.EventTypeConnecting:
					fmt.Println("Connecting to Slack with Socket Mode.")
					if s.initHandler == nil {
						continue
					}
					go s.initHandler()
				case socketmode.EventTypeConnectionError:
					fmt.Println("Connection failed. Retrying later...")
				case socketmode.EventTypeConnected:
					fmt.Println("Connected to Slack with Socket Mode.")
				case socketmode.EventTypeHello:
					s.appID = evt.Request.ConnectionInfo.AppID
					fmt.Printf("Connected as App ID %v\n", s.appID)
				case socketmode.EventTypeEventsAPI:
					ev, ok := evt.Data.(slackevents.EventsAPIEvent)
					if !ok {
						fmt.Printf("Ignored %+v\n", evt)
						continue
					}
					switch ev.InnerEvent.Type {
					case "message", "app_mention":  
						go s.handleMessageEvent(ctx, ev.InnerEvent.Data)
					default:
						fmt.Printf("unsupported inner event: %+v\n", ev.InnerEvent.Type)
					}
					s.socketModeClient.Ack(*evt.Request)
				case socketmode.EventTypeInteractive:
					if s.interactiveEventHandler == nil {
						s.unsupportedEventReceived()
						continue
					}
					callback, ok := evt.Data.(slack.InteractionCallback)
					if !ok {
						fmt.Printf("Ignored %+v\n", evt)
						continue
					}
					go s.interactiveEventHandler(s, &evt, &callback)
				default:
					s.unsupportedEventReceived()
				}
			}
		}
	}()
	return s.socketModeClient.RunContext(ctx)
}
func (s *Slacker) unsupportedEventReceived() {
	s.socketModeClient.Debugf("unsupported Events API event received")
}