Update dependencies / vendor (#1146)

159 files changed, 4849 insertions, 1058 deletions

diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/chat.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/chat.go
index 3eca02cd..1ca7d431 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/chat.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/chat.go
@@ -70,7 +70,11 @@ func (a *API) GetConversations(unreadOnly bool) ([]chat1.ConvSummary, error) {
 }
 
 func (a *API) GetConversation(convID chat1.ConvIDStr) (res chat1.ConvSummary, err error) {
-	apiInput := fmt.Sprintf(`{"method":"list", "params": { "options": { "conversation_id": "%s"}}}`, convID)
+	convIDEscaped, err := json.Marshal(convID)
+	if err != nil {
+		return res, err
+	}
+	apiInput := fmt.Sprintf(`{"method":"list", "params": { "options": { "conversation_id": %s}}}`, convIDEscaped)
 	output, err := a.doFetch(apiInput)
 	if err != nil {
 		return res, err
@@ -94,7 +98,7 @@ func (a *API) GetTextMessages(channel chat1.ChatChannel, unreadOnly bool) ([]cha
 	if err != nil {
 		return nil, err
 	}
-	apiInput := fmt.Sprintf(`{"method": "read", "params": {"options": {"channel": %s}}}`, string(channelBytes))
+	apiInput := fmt.Sprintf(`{"method": "read", "params": {"options": {"channel": %s}}}`, channelBytes)
 	output, err := a.doFetch(apiInput)
 	if err != nil {
 		return nil, err
@@ -324,7 +328,11 @@ type LeaveChannel struct {
 }
 
 func (a *API) ListChannels(teamName string) ([]string, error) {
-	apiInput := fmt.Sprintf(`{"method": "listconvsonname", "params": {"options": {"topic_type": "CHAT", "members_type": "team", "name": "%s"}}}`, teamName)
+	teamNameEscaped, err := json.Marshal(teamName)
+	if err != nil {
+		return nil, err
+	}
+	apiInput := fmt.Sprintf(`{"method": "listconvsonname", "params": {"options": {"topic_type": "CHAT", "members_type": "team", "name": %s}}}`, teamNameEscaped)
 	output, err := a.doFetch(apiInput)
 	if err != nil {
 		return nil, err
@@ -347,7 +355,16 @@ func (a *API) ListChannels(teamName string) ([]string, error) {
 func (a *API) JoinChannel(teamName string, channelName string) (chat1.EmptyRes, error) {
 	empty := chat1.EmptyRes{}
 
-	apiInput := fmt.Sprintf(`{"method": "join", "params": {"options": {"channel": {"name": "%s", "members_type": "team", "topic_name": "%s"}}}}`, teamName, channelName)
+	teamNameEscaped, err := json.Marshal(teamName)
+	if err != nil {
+		return empty, err
+	}
+	channelNameEscaped, err := json.Marshal(channelName)
+	if err != nil {
+		return empty, err
+	}
+	apiInput := fmt.Sprintf(`{"method": "join", "params": {"options": {"channel": {"name": %s, "members_type": "team", "topic_name": %s}}}}`,
+		teamNameEscaped, channelNameEscaped)
 	output, err := a.doFetch(apiInput)
 	if err != nil {
 		return empty, err
@@ -367,7 +384,16 @@ func (a *API) JoinChannel(teamName string, channelName string) (chat1.EmptyRes,
 func (a *API) LeaveChannel(teamName string, channelName string) (chat1.EmptyRes, error) {
 	empty := chat1.EmptyRes{}
 
-	apiInput := fmt.Sprintf(`{"method": "leave", "params": {"options": {"channel": {"name": "%s", "members_type": "team", "topic_name": "%s"}}}}`, teamName, channelName)
+	teamNameEscaped, err := json.Marshal(teamName)
+	if err != nil {
+		return empty, err
+	}
+	channelNameEscaped, err := json.Marshal(channelName)
+	if err != nil {
+		return empty, err
+	}
+	apiInput := fmt.Sprintf(`{"method": "leave", "params": {"options": {"channel": {"name": %s, "members_type": "team", "topic_name": %s}}}}`,
+		teamNameEscaped, channelNameEscaped)
 	output, err := a.doFetch(apiInput)
 	if err != nil {
 		return empty, err
@@ -461,13 +487,28 @@ func (a *API) AdvertiseCommands(ad Advertisement) (SendResponse, error) {
 	return a.doSend(newAdvertiseCmdsMsgArg(ad))
 }
 
-func (a *API) ClearCommands() error {
-	arg := struct {
-		Method string
-	}{
+type clearCmdsOptions struct {
+	Filter *chat1.ClearCommandAPIParam `json:"filter"`
+}
+
+type clearCmdsParams struct {
+	Options clearCmdsOptions `json:"options"`
+}
+
+type clearCmdsArg struct {
+	Method string          `json:"method"`
+	Params clearCmdsParams `json:"params,omitempty"`
+}
+
+func (a *API) ClearCommands(filter *chat1.ClearCommandAPIParam) error {
+	_, err := a.doSend(clearCmdsArg{
 		Method: "clearcommands",
-	}
-	_, err := a.doSend(arg)
+		Params: clearCmdsParams{
+			Options: clearCmdsOptions{
+				Filter: filter,
+			},
+		},
+	})
 	return err
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/errors.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/errors.go
index 2b8e929d..1d1e6315 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/errors.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/errors.go
@@ -1,9 +1,14 @@
 package kbchat
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 type ErrorCode int
 
+var errAPIDisconnected = errors.New("chat API disconnected")
+
 const (
 	RevisionErrorCode          ErrorCode = 2760
 	DeleteNonExistentErrorCode ErrorCode = 2762
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kbchat.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kbchat.go
index de76e75a..68c8ca70 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kbchat.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/kbchat.go
@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"io"
 	"io/ioutil"
-	"log"
 	"os"
 	"os/exec"
 	"sync"
@@ -18,63 +17,110 @@ import (
 	"github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1"
 )
 
-// API is the main object used for communicating with the Keybase JSON API
-type API struct {
+// SubscriptionMessage contains a message and conversation object
+type SubscriptionMessage struct {
+	Message      chat1.MsgSummary
+	Conversation chat1.ConvSummary
+}
+
+type SubscriptionConversation struct {
+	Conversation chat1.ConvSummary
+}
+
+type SubscriptionWalletEvent struct {
+	Payment stellar1.PaymentDetailsLocal
+}
+
+// Subscription has methods to control the background message fetcher loop
+type Subscription struct {
+	*DebugOutput
 	sync.Mutex
-	apiInput      io.Writer
-	apiOutput     *bufio.Reader
-	apiCmd        *exec.Cmd
-	username      string
-	runOpts       RunOptions
-	subscriptions []*NewSubscription
+
+	newMsgsCh   chan SubscriptionMessage
+	newConvsCh  chan SubscriptionConversation
+	newWalletCh chan SubscriptionWalletEvent
+	errorCh     chan error
+	running     bool
+	shutdownCh  chan struct{}
 }
 
-func getUsername(runOpts RunOptions) (username string, err error) {
-	p := runOpts.Command("whoami", "-json")
-	output, err := p.StdoutPipe()
-	if err != nil {
-		return "", err
+func NewSubscription() *Subscription {
+	newMsgsCh := make(chan SubscriptionMessage, 100)
+	newConvsCh := make(chan SubscriptionConversation, 100)
+	newWalletCh := make(chan SubscriptionWalletEvent, 100)
+	errorCh := make(chan error, 100)
+	shutdownCh := make(chan struct{})
+	return &Subscription{
+		DebugOutput: NewDebugOutput("Subscription"),
+		newMsgsCh:   newMsgsCh,
+		newConvsCh:  newConvsCh,
+		newWalletCh: newWalletCh,
+		shutdownCh:  shutdownCh,
+		errorCh:     errorCh,
+		running:     true,
 	}
-	p.ExtraFiles = []*os.File{output.(*os.File)}
-	if err = p.Start(); err != nil {
-		return "", err
+}
+
+// Read blocks until a new message arrives
+func (m *Subscription) Read() (msg SubscriptionMessage, err error) {
+	defer m.Trace(&err, "Read")()
+	select {
+	case msg = <-m.newMsgsCh:
+		return msg, nil
+	case err = <-m.errorCh:
+		return SubscriptionMessage{}, err
+	case <-m.shutdownCh:
+		return SubscriptionMessage{}, errors.New("Subscription shutdown")
 	}
+}
 
-	doneCh := make(chan error)
-	go func() {
-		defer func() { close(doneCh) }()
-		statusJSON, err := ioutil.ReadAll(output)
-		if err != nil {
-			doneCh <- fmt.Errorf("error reading whoami output: %v", err)
-			return
-		}
-		var status keybase1.CurrentStatus
-		if err := json.Unmarshal(statusJSON, &status); err != nil {
-			doneCh <- fmt.Errorf("invalid whoami JSON %q: %v", statusJSON, err)
-			return
-		}
-		if status.LoggedIn && status.User != nil {
-			username = status.User.Username
-			doneCh <- nil
-		} else {
-			doneCh <- fmt.Errorf("unable to authenticate to keybase service: logged in: %v user: %+v", status.LoggedIn, status.User)
-		}
-		// Cleanup the command
-		if err := p.Wait(); err != nil {
-			log.Printf("unable to wait for cmd: %v", err)
-		}
-	}()
+func (m *Subscription) ReadNewConvs() (conv SubscriptionConversation, err error) {
+	defer m.Trace(&err, "ReadNewConvs")()
+	select {
+	case conv = <-m.newConvsCh:
+		return conv, nil
+	case err = <-m.errorCh:
+		return SubscriptionConversation{}, err
+	case <-m.shutdownCh:
+		return SubscriptionConversation{}, errors.New("Subscription shutdown")
+	}
+}
 
+// Read blocks until a new message arrives
+func (m *Subscription) ReadWallet() (msg SubscriptionWalletEvent, err error) {
+	defer m.Trace(&err, "ReadWallet")()
 	select {
-	case err = <-doneCh:
-		if err != nil {
-			return "", err
-		}
-	case <-time.After(5 * time.Second):
-		return "", errors.New("unable to run Keybase command")
+	case msg = <-m.newWalletCh:
+		return msg, nil
+	case err = <-m.errorCh:
+		return SubscriptionWalletEvent{}, err
+	case <-m.shutdownCh:
+		return SubscriptionWalletEvent{}, errors.New("Subscription shutdown")
 	}
+}
 
-	return username, nil
+// Shutdown terminates the background process
+func (m *Subscription) Shutdown() {
+	defer m.Trace(nil, "Shutdown")()
+	m.Lock()
+	defer m.Unlock()
+	if m.running {
+		close(m.shutdownCh)
+		m.running = false
+	}
+}
+
+type ListenOptions struct {
+	Wallet bool
+	Convs  bool
+}
+
+type PaymentHolder struct {
+	Payment stellar1.PaymentDetailsLocal `json:"notification"`
+}
+
+type TypeHolder struct {
+	Type string `json:"type"`
 }
 
 type OneshotOptions struct {
@@ -110,22 +156,101 @@ func (r RunOptions) Command(args ...string) *exec.Cmd {
 }
 
 // Start fires up the Keybase JSON API in stdin/stdout mode
-func Start(runOpts RunOptions) (*API, error) {
-	api := &API{
-		runOpts: runOpts,
-	}
+func Start(runOpts RunOptions, opts ...func(*API)) (*API, error) {
+	api := NewAPI(runOpts, opts...)
 	if err := api.startPipes(); err != nil {
 		return nil, err
 	}
 	return api, nil
 }
 
+// API is the main object used for communicating with the Keybase JSON API
+type API struct {
+	sync.Mutex
+	*DebugOutput
+	apiInput      io.Writer
+	apiOutput     *bufio.Reader
+	apiCmd        *exec.Cmd
+	username      string
+	runOpts       RunOptions
+	subscriptions []*Subscription
+	Timeout       time.Duration
+	LogSendBytes  int
+}
+
+func CustomTimeout(timeout time.Duration) func(*API) {
+	return func(a *API) {
+		a.Timeout = timeout
+	}
+}
+
+func NewAPI(runOpts RunOptions, opts ...func(*API)) *API {
+	api := &API{
+		DebugOutput:  NewDebugOutput("API"),
+		runOpts:      runOpts,
+		Timeout:      5 * time.Second,
+		LogSendBytes: 1024 * 1024 * 5, // request 5MB so we don't get killed
+	}
+	for _, opt := range opts {
+		opt(api)
+	}
+	return api
+}
+
 func (a *API) Command(args ...string) *exec.Cmd {
 	return a.runOpts.Command(args...)
 }
 
+func (a *API) getUsername(runOpts RunOptions) (username string, err error) {
+	p := runOpts.Command("whoami", "-json")
+	output, err := p.StdoutPipe()
+	if err != nil {
+		return "", err
+	}
+	p.ExtraFiles = []*os.File{output.(*os.File)}
+	if err = p.Start(); err != nil {
+		return "", err
+	}
+
+	doneCh := make(chan error)
+	go func() {
+		defer func() { close(doneCh) }()
+		statusJSON, err := ioutil.ReadAll(output)
+		if err != nil {
+			doneCh <- fmt.Errorf("error reading whoami output: %v", err)
+			return
+		}
+		var status keybase1.CurrentStatus
+		if err := json.Unmarshal(statusJSON, &status); err != nil {
+			doneCh <- fmt.Errorf("invalid whoami JSON %q: %v", statusJSON, err)
+			return
+		}
+		if status.LoggedIn && status.User != nil {
+			username = status.User.Username
+			doneCh <- nil
+		} else {
+			doneCh <- fmt.Errorf("unable to authenticate to keybase service: logged in: %v user: %+v", status.LoggedIn, status.User)
+		}
+		// Cleanup the command
+		if err := p.Wait(); err != nil {
+			a.Debug("unable to wait for cmd: %v", err)
+		}
+	}()
+
+	select {
+	case err = <-doneCh:
+		if err != nil {
+			return "", err
+		}
+	case <-time.After(a.Timeout):
+		return "", errors.New("unable to run Keybase command")
+	}
+
+	return username, nil
+}
+
 func (a *API) auth() (string, error) {
-	username, err := getUsername(a.runOpts)
+	username, err := a.getUsername(a.runOpts)
 	if err == nil {
 		return username, nil
 	}
@@ -194,8 +319,6 @@ func (a *API) startPipes() (err error) {
 	return nil
 }
 
-var errAPIDisconnected = errors.New("chat API disconnected")
-
 func (a *API) getAPIPipesLocked() (io.Writer, *bufio.Reader, error) {
 	// this should only be called inside a lock
 	if a.apiCmd == nil {
@@ -214,7 +337,7 @@ func (a *API) doSend(arg interface{}) (resp SendResponse, err error) {
 
 	bArg, err := json.Marshal(arg)
 	if err != nil {
-		return SendResponse{}, err
+		return SendResponse{}, fmt.Errorf("unable to send arg: %+v: %v", arg, err)
 	}
 	input, output, err := a.getAPIPipesLocked()
 	if err != nil {
@@ -228,7 +351,7 @@ func (a *API) doSend(arg interface{}) (resp SendResponse, err error) {
 		return SendResponse{}, err
 	}
 	if err := json.Unmarshal(responseRaw, &resp); err != nil {
-		return resp, fmt.Errorf("failed to decode API response: %s", err)
+		return resp, fmt.Errorf("failed to decode API response: %v %v", responseRaw, err)
 	} else if resp.Error != nil {
 		return resp, errors.New(resp.Error.Message)
 	}
@@ -254,97 +377,13 @@ func (a *API) doFetch(apiInput string) ([]byte, error) {
 	return byteOutput, nil
 }
 
-// SubscriptionMessage contains a message and conversation object
-type SubscriptionMessage struct {
-	Message      chat1.MsgSummary
-	Conversation chat1.ConvSummary
-}
-
-type SubscriptionConversation struct {
-	Conversation chat1.ConvSummary
-}
-
-type SubscriptionWalletEvent struct {
-	Payment stellar1.PaymentDetailsLocal
-}
-
-// NewSubscription has methods to control the background message fetcher loop
-type NewSubscription struct {
-	sync.Mutex
-
-	newMsgsCh   <-chan SubscriptionMessage
-	newConvsCh  <-chan SubscriptionConversation
-	newWalletCh <-chan SubscriptionWalletEvent
-	errorCh     <-chan error
-	running     bool
-	shutdownCh  chan struct{}
-}
-
-// Read blocks until a new message arrives
-func (m *NewSubscription) Read() (SubscriptionMessage, error) {
-	select {
-	case msg := <-m.newMsgsCh:
-		return msg, nil
-	case err := <-m.errorCh:
-		return SubscriptionMessage{}, err
-	case <-m.shutdownCh:
-		return SubscriptionMessage{}, errors.New("Subscription shutdown")
-	}
-}
-
-func (m *NewSubscription) ReadNewConvs() (SubscriptionConversation, error) {
-	select {
-	case conv := <-m.newConvsCh:
-		return conv, nil
-	case err := <-m.errorCh:
-		return SubscriptionConversation{}, err
-	case <-m.shutdownCh:
-		return SubscriptionConversation{}, errors.New("Subscription shutdown")
-	}
-}
-
-// Read blocks until a new message arrives
-func (m *NewSubscription) ReadWallet() (SubscriptionWalletEvent, error) {
-	select {
-	case msg := <-m.newWalletCh:
-		return msg, nil
-	case err := <-m.errorCh:
-		return SubscriptionWalletEvent{}, err
-	case <-m.shutdownCh:
-		return SubscriptionWalletEvent{}, errors.New("Subscription shutdown")
-	}
-}
-
-// Shutdown terminates the background process
-func (m *NewSubscription) Shutdown() {
-	m.Lock()
-	defer m.Unlock()
-	if m.running {
-		close(m.shutdownCh)
-		m.running = false
-	}
-}
-
-type ListenOptions struct {
-	Wallet bool
-	Convs  bool
-}
-
-type PaymentHolder struct {
-	Payment stellar1.PaymentDetailsLocal `json:"notification"`
-}
-
-type TypeHolder struct {
-	Type string `json:"type"`
-}
-
 // ListenForNewTextMessages proxies to Listen without wallet events
-func (a *API) ListenForNewTextMessages() (*NewSubscription, error) {
+func (a *API) ListenForNewTextMessages() (*Subscription, error) {
 	opts := ListenOptions{Wallet: false}
 	return a.Listen(opts)
 }
 
-func (a *API) registerSubscription(sub *NewSubscription) {
+func (a *API) registerSubscription(sub *Subscription) {
 	a.Lock()
 	defer a.Unlock()
 	a.subscriptions = append(a.subscriptions, sub)
@@ -352,30 +391,17 @@ func (a *API) registerSubscription(sub *NewSubscription) {
 
 // Listen fires of a background loop and puts chat messages and wallet
 // events into channels
-func (a *API) Listen(opts ListenOptions) (*NewSubscription, error) {
-	newMsgsCh := make(chan SubscriptionMessage, 100)
-	newConvsCh := make(chan SubscriptionConversation, 100)
-	newWalletCh := make(chan SubscriptionWalletEvent, 100)
-	errorCh := make(chan error, 100)
-	shutdownCh := make(chan struct{})
+func (a *API) Listen(opts ListenOptions) (*Subscription, error) {
 	done := make(chan struct{})
-
-	sub := &NewSubscription{
-		newMsgsCh:   newMsgsCh,
-		newConvsCh:  newConvsCh,
-		newWalletCh: newWalletCh,
-		shutdownCh:  shutdownCh,
-		errorCh:     errorCh,
-		running:     true,
-	}
+	sub := NewSubscription()
 	a.registerSubscription(sub)
 	pause := 2 * time.Second
 	readScanner := func(boutput *bufio.Scanner) {
 		defer func() { done <- struct{}{} }()
 		for {
 			select {
-			case <-shutdownCh:
-				log.Printf("readScanner: received shutdown")
+			case <-sub.shutdownCh:
+				a.Debug("readScanner: received shutdown")
 				return
 			default:
 			}
@@ -383,18 +409,18 @@ func (a *API) Listen(opts ListenOptions) (*NewSubscription, error) {
 			t := boutput.Text()
 			var typeHolder TypeHolder
 			if err := json.Unmarshal([]byte(t), &typeHolder); err != nil {
-				errorCh <- err
+				sub.errorCh <- fmt.Errorf("err: %v, data: %v", err, t)
 				break
 			}
 			switch typeHolder.Type {
 			case "chat":
 				var notification chat1.MsgNotification
 				if err := json.Unmarshal([]byte(t), &notification); err != nil {
-					errorCh <- err
+					sub.errorCh <- fmt.Errorf("err: %v, data: %v", err, t)
 					break
 				}
 				if notification.Error != nil {
-					log.Printf("error message received: %s", *notification.Error)
+					a.Debug("error message received: %s", *notification.Error)
 				} else if notification.Msg != nil {
 					subscriptionMessage := SubscriptionMessage{
 						Message: *notification.Msg,
@@ -403,30 +429,30 @@ func (a *API) Listen(opts ListenOptions) (*NewSubscription, error) {
 							Channel: notification.Msg.Channel,
 						},
 					}
-					newMsgsCh <- subscriptionMessage
+					sub.newMsgsCh <- subscriptionMessage
 				}
 			case "chat_conv":
 				var notification chat1.ConvNotification
 				if err := json.Unmarshal([]byte(t), &notification); err != nil {
-					errorCh <- err
+					sub.errorCh <- fmt.Errorf("err: %v, data: %v", err, t)
 					break
 				}
 				if notification.Error != nil {
-					log.Printf("error message received: %s", *notification.Error)
+					a.Debug("error message received: %s", *notification.Error)
 				} else if notification.Conv != nil {
 					subscriptionConv := SubscriptionConversation{
 						Conversation: *notification.Conv,
 					}
-					newConvsCh <- subscriptionConv
+					sub.newConvsCh <- subscriptionConv
 				}
 			case "wallet":
 				var holder PaymentHolder
 				if err := json.Unmarshal([]byte(t), &holder); err != nil {
-					errorCh <- err
+					sub.errorCh <- fmt.Errorf("err: %v, data: %v", err, t)
 					break
 				}
 				subscriptionPayment := SubscriptionWalletEvent(holder)
-				newWalletCh <- subscriptionPayment
+				sub.newWalletCh <- subscriptionPayment
 			default:
 				continue
 			}
@@ -434,31 +460,31 @@ func (a *API) Listen(opts ListenOptions) (*NewSubscription, error) {
 	}
 
 	attempts := 0
-	maxAttempts := 1800
+	maxAttempts := 30
 	go func() {
 		defer func() {
-			close(newMsgsCh)
-			close(newConvsCh)
-			close(newWalletCh)
-			close(errorCh)
+			close(sub.newMsgsCh)
+			close(sub.newConvsCh)
+			close(sub.newWalletCh)
+			close(sub.errorCh)
 		}()
 		for {
 			select {
-			case <-shutdownCh:
-				log.Printf("Listen: received shutdown")
+			case <-sub.shutdownCh:
+				a.Debug("Listen: received shutdown")
 				return
 			default:
 			}
 
 			if attempts >= maxAttempts {
 				if err := a.LogSend("Listen: failed to auth, giving up"); err != nil {
-					log.Printf("Listen: logsend failed to send: %v", err)
+					a.Debug("Listen: logsend failed to send: %v", err)
 				}
 				panic("Listen: failed to auth, giving up")
 			}
 			attempts++
 			if _, err := a.auth(); err != nil {
-				log.Printf("Listen: failed to auth: %s", err)
+				a.Debug("Listen: failed to auth: %s", err)
 				time.Sleep(pause)
 				continue
 			}
@@ -472,13 +498,13 @@ func (a *API) Listen(opts ListenOptions) (*NewSubscription, error) {
 			p := a.runOpts.Command(cmdElements...)
 			output, err := p.StdoutPipe()
 			if err != nil {
-				log.Printf("Listen: failed to listen: %s", err)
+				a.Debug("Listen: failed to listen: %s", err)
 				time.Sleep(pause)
 				continue
 			}
 			stderr, err := p.StderrPipe()
 			if err != nil {
-				log.Printf("Listen: failed to listen to stderr: %s", err)
+				a.Debug("Listen: failed to listen to stderr: %s", err)
 				time.Sleep(pause)
 				continue
 			}
@@ -486,19 +512,27 @@ func (a *API) Listen(opts ListenOptions) (*NewSubscription, error) {
 			boutput := bufio.NewScanner(output)
 			if err := p.Start(); err != nil {
 
-				log.Printf("Listen: failed to make listen scanner: %s", err)
+				a.Debug("Listen: failed to make listen scanner: %s", err)
 				time.Sleep(pause)
 				continue
 			}
 			attempts = 0
 			go readScanner(boutput)
-			<-done
+			select {
+			case <-sub.shutdownCh:
+				a.Debug("Listen: received shutdown")
+				return
+			case <-done:
+			}
 			if err := p.Wait(); err != nil {
 				stderrBytes, rerr := ioutil.ReadAll(stderr)
 				if rerr != nil {
-					stderrBytes = []byte("failed to get stderr")
+					stderrBytes = []byte(fmt.Sprintf("failed to get stderr: %v", rerr))
+				}
+				a.Debug("Listen: failed to Wait for command, restarting pipes: %s (```%s```)", err, stderrBytes)
+				if err := a.startPipes(); err != nil {
+					a.Debug("Listen: failed to restart pipes: %v", err)
 				}
-				log.Printf("Listen: failed to Wait for command: %s (```%s```)", err, stderrBytes)
 			}
 			time.Sleep(pause)
 		}
@@ -515,31 +549,27 @@ func (a *API) LogSend(feedback string) error {
 		"log", "send",
 		"--no-confirm",
 		"--feedback", feedback,
+		"-n", fmt.Sprintf("%d", a.LogSendBytes),
 	}
-
-	// We're determining whether the service is already running by running status
-	// with autofork disabled.
-	if err := a.runOpts.Command("--no-auto-fork", "status"); err != nil {
-		// Assume that there's no service running, so log send as standalone
-		args = append([]string{"--standalone"}, args...)
-	}
-
 	return a.runOpts.Command(args...).Run()
 }
 
-func (a *API) Shutdown() error {
+func (a *API) Shutdown() (err error) {
+	defer a.Trace(&err, "Shutdown")()
 	a.Lock()
 	defer a.Unlock()
 	for _, sub := range a.subscriptions {
 		sub.Shutdown()
 	}
 	if a.apiCmd != nil {
+		a.Debug("waiting for API command")
 		if err := a.apiCmd.Wait(); err != nil {
 			return err
 		}
 	}
 
 	if a.runOpts.Oneshot != nil {
+		a.Debug("logging out")
 		err := a.runOpts.Command("logout", "--force").Run()
 		if err != nil {
 			return err
@@ -547,6 +577,7 @@ func (a *API) Shutdown() error {
 	}
 
 	if a.runOpts.StartService {
+		a.Debug("stopping service")
 		err := a.runOpts.Command("ctl", "stop", "--shutdown").Run()
 		if err != nil {
 			return err
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/team.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/team.go
index 71ec37d3..d3fa57ea 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/team.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/team.go
@@ -26,7 +26,11 @@ type ListUserMemberships struct {
 }
 
 func (a *API) ListMembersOfTeam(teamName string) (res keybase1.TeamMembersDetails, err error) {
-	apiInput := fmt.Sprintf(`{"method": "list-team-memberships", "params": {"options": {"team": "%s"}}}`, teamName)
+	teamNameEscaped, err := json.Marshal(teamName)
+	if err != nil {
+		return res, err
+	}
+	apiInput := fmt.Sprintf(`{"method": "list-team-memberships", "params": {"options": {"team": %s}}}`, teamNameEscaped)
 	cmd := a.runOpts.Command("team", "api")
 	cmd.Stdin = strings.NewReader(apiInput)
 	var stderr bytes.Buffer
@@ -51,7 +55,11 @@ func (a *API) ListMembersOfTeam(teamName string) (res keybase1.TeamMembersDetail
 }
 
 func (a *API) ListUserMemberships(username string) ([]keybase1.AnnotatedMemberInfo, error) {
-	apiInput := fmt.Sprintf(`{"method": "list-user-memberships", "params": {"options": {"username": "%s"}}}`, username)
+	usernameEscaped, err := json.Marshal(username)
+	if err != nil {
+		return nil, err
+	}
+	apiInput := fmt.Sprintf(`{"method": "list-user-memberships", "params": {"options": {"username": %s}}}`, usernameEscaped)
 	cmd := a.runOpts.Command("team", "api")
 	cmd.Stdin = strings.NewReader(apiInput)
 	var stderr bytes.Buffer
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/api.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/api.go
index 678d2ab3..d6c13496 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/api.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/api.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/api.avdl
 
 package chat1
@@ -139,9 +139,119 @@ func (o MsgFlipContent) DeepCopy() MsgFlipContent {
 	}
 }
 
+type EmojiContent struct {
+	Alias       string     `codec:"alias" json:"alias"`
+	IsCrossTeam bool       `codec:"isCrossTeam" json:"isCrossTeam"`
+	ConvID      *ConvIDStr `codec:"convID,omitempty" json:"convID,omitempty"`
+	MessageID   *MessageID `codec:"messageID,omitempty" json:"messageID,omitempty"`
+}
+
+func (o EmojiContent) DeepCopy() EmojiContent {
+	return EmojiContent{
+		Alias:       o.Alias,
+		IsCrossTeam: o.IsCrossTeam,
+		ConvID: (func(x *ConvIDStr) *ConvIDStr {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ConvID),
+		MessageID: (func(x *MessageID) *MessageID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.MessageID),
+	}
+}
+
+type MsgTextContent struct {
+	Body         string             `codec:"body" json:"body"`
+	Payments     []TextPayment      `codec:"payments" json:"payments"`
+	ReplyTo      *MessageID         `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
+	ReplyToUID   *string            `codec:"replyToUID,omitempty" json:"replyToUID,omitempty"`
+	UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"`
+	TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"`
+	LiveLocation *LiveLocation      `codec:"liveLocation,omitempty" json:"liveLocation,omitempty"`
+	Emojis       []EmojiContent     `codec:"emojis" json:"emojis"`
+}
+
+func (o MsgTextContent) DeepCopy() MsgTextContent {
+	return MsgTextContent{
+		Body: o.Body,
+		Payments: (func(x []TextPayment) []TextPayment {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TextPayment, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Payments),
+		ReplyTo: (func(x *MessageID) *MessageID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ReplyTo),
+		ReplyToUID: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ReplyToUID),
+		UserMentions: (func(x []KnownUserMention) []KnownUserMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]KnownUserMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.UserMentions),
+		TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]KnownTeamMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.TeamMentions),
+		LiveLocation: (func(x *LiveLocation) *LiveLocation {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.LiveLocation),
+		Emojis: (func(x []EmojiContent) []EmojiContent {
+			if x == nil {
+				return nil
+			}
+			ret := make([]EmojiContent, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
+	}
+}
+
 type MsgContent struct {
 	TypeName           string                       `codec:"typeName" json:"type"`
-	Text               *MessageText                 `codec:"text,omitempty" json:"text,omitempty"`
+	Text               *MsgTextContent              `codec:"text,omitempty" json:"text,omitempty"`
 	Attachment         *MessageAttachment           `codec:"attachment,omitempty" json:"attachment,omitempty"`
 	Edit               *MessageEdit                 `codec:"edit,omitempty" json:"edit,omitempty"`
 	Reaction           *MessageReaction             `codec:"reaction,omitempty" json:"reaction,omitempty"`
@@ -159,7 +269,7 @@ type MsgContent struct {
 func (o MsgContent) DeepCopy() MsgContent {
 	return MsgContent{
 		TypeName: o.TypeName,
-		Text: (func(x *MessageText) *MessageText {
+		Text: (func(x *MsgTextContent) *MsgTextContent {
 			if x == nil {
 				return nil
 			}
@@ -269,7 +379,7 @@ type MsgSummary struct {
 	IsEphemeral         bool                     `codec:"isEphemeral,omitempty" json:"is_ephemeral,omitempty"`
 	IsEphemeralExpired  bool                     `codec:"isEphemeralExpired,omitempty" json:"is_ephemeral_expired,omitempty"`
 	ETime               gregor1.Time             `codec:"eTime,omitempty" json:"e_time,omitempty"`
-	Reactions           *ReactionMap             `codec:"reactions,omitempty" json:"reactions,omitempty"`
+	Reactions           *UIReactionMap           `codec:"reactions,omitempty" json:"reactions,omitempty"`
 	HasPairwiseMacs     bool                     `codec:"hasPairwiseMacs,omitempty" json:"has_pairwise_macs,omitempty"`
 	AtMentionUsernames  []string                 `codec:"atMentionUsernames,omitempty" json:"at_mention_usernames,omitempty"`
 	ChannelMention      string                   `codec:"channelMention,omitempty" json:"channel_mention,omitempty"`
@@ -304,7 +414,7 @@ func (o MsgSummary) DeepCopy() MsgSummary {
 		IsEphemeral:        o.IsEphemeral,
 		IsEphemeralExpired: o.IsEphemeralExpired,
 		ETime:              o.ETime.DeepCopy(),
-		Reactions: (func(x *ReactionMap) *ReactionMap {
+		Reactions: (func(x *UIReactionMap) *UIReactionMap {
 			if x == nil {
 				return nil
 			}
@@ -832,6 +942,7 @@ type AdvertiseCommandAPIParam struct {
 	Typ      string                `codec:"typ" json:"type"`
 	Commands []UserBotCommandInput `codec:"commands" json:"commands"`
 	TeamName string                `codec:"teamName,omitempty" json:"team_name,omitempty"`
+	ConvID   ConvIDStr             `codec:"convID,omitempty" json:"conv_id,omitempty"`
 }
 
 func (o AdvertiseCommandAPIParam) DeepCopy() AdvertiseCommandAPIParam {
@@ -849,6 +960,21 @@ func (o AdvertiseCommandAPIParam) DeepCopy() AdvertiseCommandAPIParam {
 			return ret
 		})(o.Commands),
 		TeamName: o.TeamName,
+		ConvID:   o.ConvID.DeepCopy(),
+	}
+}
+
+type ClearCommandAPIParam struct {
+	Typ      string    `codec:"typ" json:"type"`
+	TeamName string    `codec:"teamName,omitempty" json:"team_name,omitempty"`
+	ConvID   ConvIDStr `codec:"convID,omitempty" json:"conv_id,omitempty"`
+}
+
+func (o ClearCommandAPIParam) DeepCopy() ClearCommandAPIParam {
+	return ClearCommandAPIParam{
+		Typ:      o.Typ,
+		TeamName: o.TeamName,
+		ConvID:   o.ConvID.DeepCopy(),
 	}
 }
 
@@ -897,17 +1023,17 @@ func (o GetResetConvMembersRes) DeepCopy() GetResetConvMembersRes {
 }
 
 type DeviceInfo struct {
-	DeviceID          keybase1.DeviceID `codec:"deviceID" json:"id"`
-	DeviceDescription string            `codec:"deviceDescription" json:"description"`
-	DeviceType        string            `codec:"deviceType" json:"type"`
-	DeviceCtime       int64             `codec:"deviceCtime" json:"ctime"`
+	DeviceID          keybase1.DeviceID     `codec:"deviceID" json:"id"`
+	DeviceDescription string                `codec:"deviceDescription" json:"description"`
+	DeviceType        keybase1.DeviceTypeV2 `codec:"deviceType" json:"type"`
+	DeviceCtime       int64                 `codec:"deviceCtime" json:"ctime"`
 }
 
 func (o DeviceInfo) DeepCopy() DeviceInfo {
 	return DeviceInfo{
 		DeviceID:          o.DeviceID.DeepCopy(),
 		DeviceDescription: o.DeviceDescription,
-		DeviceType:        o.DeviceType,
+		DeviceType:        o.DeviceType.DeepCopy(),
 		DeviceCtime:       o.DeviceCtime,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/blocking.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/blocking.go
index 37c5c78a..bc6da3eb 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/blocking.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/blocking.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/blocking.avdl
 
 package chat1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/chat_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/chat_ui.go
index 1a908099..40ce655e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/chat_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/chat_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/chat_ui.avdl
 
 package chat1
@@ -537,6 +537,7 @@ type InboxUIItem struct {
 	IsDefaultConv     bool                          `codec:"isDefaultConv" json:"isDefaultConv"`
 	Name              string                        `codec:"name" json:"name"`
 	Snippet           string                        `codec:"snippet" json:"snippet"`
+	SnippetDecorated  string                        `codec:"snippetDecorated" json:"snippetDecorated"`
 	SnippetDecoration SnippetDecoration             `codec:"snippetDecoration" json:"snippetDecoration"`
 	Channel           string                        `codec:"channel" json:"channel"`
 	Headline          string                        `codec:"headline" json:"headline"`
@@ -579,6 +580,7 @@ func (o InboxUIItem) DeepCopy() InboxUIItem {
 		IsDefaultConv:     o.IsDefaultConv,
 		Name:              o.Name,
 		Snippet:           o.Snippet,
+		SnippetDecorated:  o.SnippetDecorated,
 		SnippetDecoration: o.SnippetDecoration.DeepCopy(),
 		Channel:           o.Channel,
 		Headline:          o.Headline,
@@ -889,6 +891,50 @@ func (o UIMessageUnfurlInfo) DeepCopy() UIMessageUnfurlInfo {
 	}
 }
 
+type UIReactionDesc struct {
+	Decorated string              `codec:"decorated" json:"decorated"`
+	Users     map[string]Reaction `codec:"users" json:"users"`
+}
+
+func (o UIReactionDesc) DeepCopy() UIReactionDesc {
+	return UIReactionDesc{
+		Decorated: o.Decorated,
+		Users: (func(x map[string]Reaction) map[string]Reaction {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]Reaction, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Users),
+	}
+}
+
+type UIReactionMap struct {
+	Reactions map[string]UIReactionDesc `codec:"reactions" json:"reactions"`
+}
+
+func (o UIReactionMap) DeepCopy() UIReactionMap {
+	return UIReactionMap{
+		Reactions: (func(x map[string]UIReactionDesc) map[string]UIReactionDesc {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]UIReactionDesc, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Reactions),
+	}
+}
+
 type UIMessageValid struct {
 	MessageID             MessageID              `codec:"messageID" json:"messageID"`
 	Ctime                 gregor1.Time           `codec:"ctime" json:"ctime"`
@@ -898,7 +944,7 @@ type UIMessageValid struct {
 	BodySummary           string                 `codec:"bodySummary" json:"bodySummary"`
 	SenderUsername        string                 `codec:"senderUsername" json:"senderUsername"`
 	SenderDeviceName      string                 `codec:"senderDeviceName" json:"senderDeviceName"`
-	SenderDeviceType      string                 `codec:"senderDeviceType" json:"senderDeviceType"`
+	SenderDeviceType      keybase1.DeviceTypeV2  `codec:"senderDeviceType" json:"senderDeviceType"`
 	SenderUID             gregor1.UID            `codec:"senderUID" json:"senderUID"`
 	SenderDeviceID        gregor1.DeviceID       `codec:"senderDeviceID" json:"senderDeviceID"`
 	Superseded            bool                   `codec:"superseded" json:"superseded"`
@@ -911,7 +957,7 @@ type UIMessageValid struct {
 	IsEphemeralExpired    bool                   `codec:"isEphemeralExpired" json:"isEphemeralExpired"`
 	ExplodedBy            *string                `codec:"explodedBy,omitempty" json:"explodedBy,omitempty"`
 	Etime                 gregor1.Time           `codec:"etime" json:"etime"`
-	Reactions             ReactionMap            `codec:"reactions" json:"reactions"`
+	Reactions             UIReactionMap          `codec:"reactions" json:"reactions"`
 	HasPairwiseMacs       bool                   `codec:"hasPairwiseMacs" json:"hasPairwiseMacs"`
 	PaymentInfos          []UIPaymentInfo        `codec:"paymentInfos" json:"paymentInfos"`
 	RequestInfo           *UIRequestInfo         `codec:"requestInfo,omitempty" json:"requestInfo,omitempty"`
@@ -947,7 +993,7 @@ func (o UIMessageValid) DeepCopy() UIMessageValid {
 		BodySummary:      o.BodySummary,
 		SenderUsername:   o.SenderUsername,
 		SenderDeviceName: o.SenderDeviceName,
-		SenderDeviceType: o.SenderDeviceType,
+		SenderDeviceType: o.SenderDeviceType.DeepCopy(),
 		SenderUID:        o.SenderUID.DeepCopy(),
 		SenderDeviceID:   o.SenderDeviceID.DeepCopy(),
 		Superseded:       o.Superseded,
@@ -1068,6 +1114,7 @@ type UIMessageOutbox struct {
 	IsEphemeral       bool            `codec:"isEphemeral" json:"isEphemeral"`
 	FlipGameID        *FlipGameIDStr  `codec:"flipGameID,omitempty" json:"flipGameID,omitempty"`
 	ReplyTo           *UIMessage      `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
+	Supersedes        MessageID       `codec:"supersedes" json:"supersedes"`
 	Filename          string          `codec:"filename" json:"filename"`
 	Title             string          `codec:"title" json:"title"`
 	Preview           *MakePreviewRes `codec:"preview,omitempty" json:"preview,omitempty"`
@@ -1103,8 +1150,9 @@ func (o UIMessageOutbox) DeepCopy() UIMessageOutbox {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.ReplyTo),
-		Filename: o.Filename,
-		Title:    o.Title,
+		Supersedes: o.Supersedes.DeepCopy(),
+		Filename:   o.Filename,
+		Title:      o.Title,
 		Preview: (func(x *MakePreviewRes) *MakePreviewRes {
 			if x == nil {
 				return nil
@@ -1418,6 +1466,7 @@ const (
 	UITextDecorationTyp_LINK               UITextDecorationTyp = 4
 	UITextDecorationTyp_MAILTO             UITextDecorationTyp = 5
 	UITextDecorationTyp_KBFSPATH           UITextDecorationTyp = 6
+	UITextDecorationTyp_EMOJI              UITextDecorationTyp = 7
 )
 
 func (o UITextDecorationTyp) DeepCopy() UITextDecorationTyp { return o }
@@ -1430,6 +1479,7 @@ var UITextDecorationTypMap = map[string]UITextDecorationTyp{
 	"LINK":               4,
 	"MAILTO":             5,
 	"KBFSPATH":           6,
+	"EMOJI":              7,
 }
 
 var UITextDecorationTypRevMap = map[UITextDecorationTyp]string{
@@ -1440,6 +1490,7 @@ var UITextDecorationTypRevMap = map[UITextDecorationTyp]string{
 	4: "LINK",
 	5: "MAILTO",
 	6: "KBFSPATH",
+	7: "EMOJI",
 }
 
 func (e UITextDecorationTyp) String() string {
@@ -1566,6 +1617,7 @@ type UITextDecoration struct {
 	Link__               *UILinkDecoration     `codec:"link,omitempty" json:"link,omitempty"`
 	Mailto__             *UILinkDecoration     `codec:"mailto,omitempty" json:"mailto,omitempty"`
 	Kbfspath__           *KBFSPath             `codec:"kbfspath,omitempty" json:"kbfspath,omitempty"`
+	Emoji__              *Emoji                `codec:"emoji,omitempty" json:"emoji,omitempty"`
 }
 
 func (o *UITextDecoration) Typ() (ret UITextDecorationTyp, err error) {
@@ -1605,6 +1657,11 @@ func (o *UITextDecoration) Typ() (ret UITextDecorationTyp, err error) {
 			err = errors.New("unexpected nil value for Kbfspath__")
 			return ret, err
 		}
+	case UITextDecorationTyp_EMOJI:
+		if o.Emoji__ == nil {
+			err = errors.New("unexpected nil value for Emoji__")
+			return ret, err
+		}
 	}
 	return o.Typ__, nil
 }
@@ -1679,6 +1736,16 @@ func (o UITextDecoration) Kbfspath() (res KBFSPath) {
 	return *o.Kbfspath__
 }
 
+func (o UITextDecoration) Emoji() (res Emoji) {
+	if o.Typ__ != UITextDecorationTyp_EMOJI {
+		panic("wrong case accessed")
+	}
+	if o.Emoji__ == nil {
+		return
+	}
+	return *o.Emoji__
+}
+
 func NewUITextDecorationWithPayment(v TextPayment) UITextDecoration {
 	return UITextDecoration{
 		Typ__:     UITextDecorationTyp_PAYMENT,
@@ -1728,6 +1795,13 @@ func NewUITextDecorationWithKbfspath(v KBFSPath) UITextDecoration {
 	}
 }
 
+func NewUITextDecorationWithEmoji(v Emoji) UITextDecoration {
+	return UITextDecoration{
+		Typ__:   UITextDecorationTyp_EMOJI,
+		Emoji__: &v,
+	}
+}
+
 func (o UITextDecoration) DeepCopy() UITextDecoration {
 	return UITextDecoration{
 		Typ__: o.Typ__.DeepCopy(),
@@ -1780,6 +1854,13 @@ func (o UITextDecoration) DeepCopy() UITextDecoration {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.Kbfspath__),
+		Emoji__: (func(x *Emoji) *Emoji {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Emoji__),
 	}
 }
 
@@ -1917,6 +1998,50 @@ func (o UIChatSearchConvHits) DeepCopy() UIChatSearchConvHits {
 	}
 }
 
+type UIChatSearchTeamHits struct {
+	Hits             []keybase1.TeamSearchItem `codec:"hits" json:"hits"`
+	SuggestedMatches bool                      `codec:"suggestedMatches" json:"suggestedMatches"`
+}
+
+func (o UIChatSearchTeamHits) DeepCopy() UIChatSearchTeamHits {
+	return UIChatSearchTeamHits{
+		Hits: (func(x []keybase1.TeamSearchItem) []keybase1.TeamSearchItem {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.TeamSearchItem, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Hits),
+		SuggestedMatches: o.SuggestedMatches,
+	}
+}
+
+type UIChatSearchBotHits struct {
+	Hits             []keybase1.FeaturedBot `codec:"hits" json:"hits"`
+	SuggestedMatches bool                   `codec:"suggestedMatches" json:"suggestedMatches"`
+}
+
+func (o UIChatSearchBotHits) DeepCopy() UIChatSearchBotHits {
+	return UIChatSearchBotHits{
+		Hits: (func(x []keybase1.FeaturedBot) []keybase1.FeaturedBot {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.FeaturedBot, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Hits),
+		SuggestedMatches: o.SuggestedMatches,
+	}
+}
+
 type UIChatPayment struct {
 	Username      string  `codec:"username" json:"username"`
 	FullName      string  `codec:"fullName" json:"fullName"`
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/commands.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/commands.go
index f6d4d556..6a28d100 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/commands.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/commands.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/commands.avdl
 
 package chat1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/common.go
index 60eff96d..530c49c1 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/common.avdl
 
 package chat1
@@ -9,6 +9,7 @@ import (
 
 	gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1"
 	keybase1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1"
+	stellar1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1"
 )
 
 type ThreadID []byte
@@ -311,6 +312,8 @@ const (
 	TopicType_CHAT         TopicType = 1
 	TopicType_DEV          TopicType = 2
 	TopicType_KBFSFILEEDIT TopicType = 3
+	TopicType_EMOJI        TopicType = 4
+	TopicType_EMOJICROSS   TopicType = 5
 )
 
 func (o TopicType) DeepCopy() TopicType { return o }
@@ -320,6 +323,8 @@ var TopicTypeMap = map[string]TopicType{
 	"CHAT":         1,
 	"DEV":          2,
 	"KBFSFILEEDIT": 3,
+	"EMOJI":        4,
+	"EMOJICROSS":   5,
 }
 
 var TopicTypeRevMap = map[TopicType]string{
@@ -327,6 +332,8 @@ var TopicTypeRevMap = map[TopicType]string{
 	1: "CHAT",
 	2: "DEV",
 	3: "KBFSFILEEDIT",
+	4: "EMOJI",
+	5: "EMOJICROSS",
 }
 
 type TeamType int
@@ -627,6 +634,32 @@ func (o RateLimit) DeepCopy() RateLimit {
 	}
 }
 
+type InboxParticipantsMode int
+
+const (
+	InboxParticipantsMode_ALL        InboxParticipantsMode = 0
+	InboxParticipantsMode_SKIP_TEAMS InboxParticipantsMode = 1
+)
+
+func (o InboxParticipantsMode) DeepCopy() InboxParticipantsMode { return o }
+
+var InboxParticipantsModeMap = map[string]InboxParticipantsMode{
+	"ALL":        0,
+	"SKIP_TEAMS": 1,
+}
+
+var InboxParticipantsModeRevMap = map[InboxParticipantsMode]string{
+	0: "ALL",
+	1: "SKIP_TEAMS",
+}
+
+func (e InboxParticipantsMode) String() string {
+	if v, ok := InboxParticipantsModeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
 type GetInboxQuery struct {
 	ConvID            *ConversationID            `codec:"convID,omitempty" json:"convID,omitempty"`
 	TopicType         *TopicType                 `codec:"topicType,omitempty" json:"topicType,omitempty"`
@@ -645,6 +678,7 @@ type GetInboxQuery struct {
 	ReadOnly          bool                       `codec:"readOnly" json:"readOnly"`
 	ComputeActiveList bool                       `codec:"computeActiveList" json:"computeActiveList"`
 	SummarizeMaxMsgs  bool                       `codec:"summarizeMaxMsgs" json:"summarizeMaxMsgs"`
+	ParticipantsMode  InboxParticipantsMode      `codec:"participantsMode" json:"participantsMode"`
 	SkipBgLoads       bool                       `codec:"skipBgLoads" json:"skipBgLoads"`
 	AllowUnseenQuery  bool                       `codec:"allowUnseenQuery" json:"allowUnseenQuery"`
 }
@@ -766,6 +800,7 @@ func (o GetInboxQuery) DeepCopy() GetInboxQuery {
 		ReadOnly:          o.ReadOnly,
 		ComputeActiveList: o.ComputeActiveList,
 		SummarizeMaxMsgs:  o.SummarizeMaxMsgs,
+		ParticipantsMode:  o.ParticipantsMode.DeepCopy(),
 		SkipBgLoads:       o.SkipBgLoads,
 		AllowUnseenQuery:  o.AllowUnseenQuery,
 	}
@@ -959,6 +994,7 @@ type ConversationReaderInfo struct {
 	MaxMsgid          MessageID                    `codec:"maxMsgid" json:"maxMsgid"`
 	Status            ConversationMemberStatus     `codec:"status" json:"status"`
 	UntrustedTeamRole keybase1.TeamRole            `codec:"untrustedTeamRole" json:"untrustedTeamRole"`
+	LastSendTime      gregor1.Time                 `codec:"l" json:"l"`
 	Journeycard       *ConversationJourneycardInfo `codec:"jc,omitempty" json:"jc,omitempty"`
 }
 
@@ -969,6 +1005,7 @@ func (o ConversationReaderInfo) DeepCopy() ConversationReaderInfo {
 		MaxMsgid:          o.MaxMsgid.DeepCopy(),
 		Status:            o.Status.DeepCopy(),
 		UntrustedTeamRole: o.UntrustedTeamRole.DeepCopy(),
+		LastSendTime:      o.LastSendTime.DeepCopy(),
 		Journeycard: (func(x *ConversationJourneycardInfo) *ConversationJourneycardInfo {
 			if x == nil {
 				return nil
@@ -1333,6 +1370,7 @@ type MessageClientHeader struct {
 	EphemeralMetadata *MsgEphemeralMetadata    `codec:"em,omitempty" json:"em,omitempty"`
 	PairwiseMacs      map[keybase1.KID][]byte  `codec:"pm" json:"pm"`
 	BotUID            *gregor1.UID             `codec:"b,omitempty" json:"b,omitempty"`
+	TxID              *stellar1.TransactionID  `codec:"t,omitempty" json:"t,omitempty"`
 }
 
 func (o MessageClientHeader) DeepCopy() MessageClientHeader {
@@ -1432,6 +1470,13 @@ func (o MessageClientHeader) DeepCopy() MessageClientHeader {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.BotUID),
+		TxID: (func(x *stellar1.TransactionID) *stellar1.TransactionID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.TxID),
 	}
 }
 
@@ -1959,6 +2004,7 @@ const (
 	GetThreadReason_KBFSFILEACTIVITY   GetThreadReason = 8
 	GetThreadReason_COINFLIP           GetThreadReason = 9
 	GetThreadReason_BOTCOMMANDS        GetThreadReason = 10
+	GetThreadReason_EMOJISOURCE        GetThreadReason = 11
 )
 
 func (o GetThreadReason) DeepCopy() GetThreadReason { return o }
@@ -1975,6 +2021,7 @@ var GetThreadReasonMap = map[string]GetThreadReason{
 	"KBFSFILEACTIVITY":   8,
 	"COINFLIP":           9,
 	"BOTCOMMANDS":        10,
+	"EMOJISOURCE":        11,
 }
 
 var GetThreadReasonRevMap = map[GetThreadReason]string{
@@ -1989,6 +2036,7 @@ var GetThreadReasonRevMap = map[GetThreadReason]string{
 	8:  "KBFSFILEACTIVITY",
 	9:  "COINFLIP",
 	10: "BOTCOMMANDS",
+	11: "EMOJISOURCE",
 }
 
 func (e GetThreadReason) String() string {
@@ -2044,6 +2092,9 @@ type SearchOpts struct {
 	MaxConvsHit       int             `codec:"maxConvsHit" json:"maxConvsHit"`
 	ConvID            *ConversationID `codec:"convID,omitempty" json:"convID,omitempty"`
 	MaxNameConvs      int             `codec:"maxNameConvs" json:"maxNameConvs"`
+	MaxTeams          int             `codec:"maxTeams" json:"maxTeams"`
+	MaxBots           int             `codec:"maxBots" json:"maxBots"`
+	SkipBotCache      bool            `codec:"skipBotCache" json:"skipBotCache"`
 }
 
 func (o SearchOpts) DeepCopy() SearchOpts {
@@ -2076,6 +2127,9 @@ func (o SearchOpts) DeepCopy() SearchOpts {
 			return &tmp
 		})(o.ConvID),
 		MaxNameConvs: o.MaxNameConvs,
+		MaxTeams:     o.MaxTeams,
+		MaxBots:      o.MaxBots,
+		SkipBotCache: o.SkipBotCache,
 	}
 }
 
@@ -2387,6 +2441,7 @@ type Asset struct {
 	Size      int64         `codec:"size" json:"size"`
 	MimeType  string        `codec:"mimeType" json:"mimeType"`
 	EncHash   Hash          `codec:"encHash" json:"encHash"`
+	PtHash    Hash          `codec:"ptHash" json:"ptHash"`
 	Key       []byte        `codec:"key" json:"key"`
 	VerifyKey []byte        `codec:"verifyKey" json:"verifyKey"`
 	Title     string        `codec:"title" json:"title"`
@@ -2405,6 +2460,7 @@ func (o Asset) DeepCopy() Asset {
 		Size:     o.Size,
 		MimeType: o.MimeType,
 		EncHash:  o.EncHash.DeepCopy(),
+		PtHash:   o.PtHash.DeepCopy(),
 		Key: (func(x []byte) []byte {
 			if x == nil {
 				return nil
@@ -2435,6 +2491,7 @@ const (
 	BotCommandsAdvertisementTyp_PUBLIC        BotCommandsAdvertisementTyp = 0
 	BotCommandsAdvertisementTyp_TLFID_MEMBERS BotCommandsAdvertisementTyp = 1
 	BotCommandsAdvertisementTyp_TLFID_CONVS   BotCommandsAdvertisementTyp = 2
+	BotCommandsAdvertisementTyp_CONV          BotCommandsAdvertisementTyp = 3
 )
 
 func (o BotCommandsAdvertisementTyp) DeepCopy() BotCommandsAdvertisementTyp { return o }
@@ -2443,12 +2500,14 @@ var BotCommandsAdvertisementTypMap = map[string]BotCommandsAdvertisementTyp{
 	"PUBLIC":        0,
 	"TLFID_MEMBERS": 1,
 	"TLFID_CONVS":   2,
+	"CONV":          3,
 }
 
 var BotCommandsAdvertisementTypRevMap = map[BotCommandsAdvertisementTyp]string{
 	0: "PUBLIC",
 	1: "TLFID_MEMBERS",
 	2: "TLFID_CONVS",
+	3: "CONV",
 }
 
 func (e BotCommandsAdvertisementTyp) String() string {
@@ -2471,3 +2530,126 @@ func (o TeamMember) DeepCopy() TeamMember {
 		Status: o.Status.DeepCopy(),
 	}
 }
+
+type LastActiveStatus int
+
+const (
+	LastActiveStatus_NONE            LastActiveStatus = 0
+	LastActiveStatus_ACTIVE          LastActiveStatus = 1
+	LastActiveStatus_RECENTLY_ACTIVE LastActiveStatus = 2
+)
+
+func (o LastActiveStatus) DeepCopy() LastActiveStatus { return o }
+
+var LastActiveStatusMap = map[string]LastActiveStatus{
+	"NONE":            0,
+	"ACTIVE":          1,
+	"RECENTLY_ACTIVE": 2,
+}
+
+var LastActiveStatusRevMap = map[LastActiveStatus]string{
+	0: "NONE",
+	1: "ACTIVE",
+	2: "RECENTLY_ACTIVE",
+}
+
+func (e LastActiveStatus) String() string {
+	if v, ok := LastActiveStatusRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type ChatMemberDetails struct {
+	Uid      keybase1.UID      `codec:"uid" json:"uid"`
+	Username string            `codec:"username" json:"username"`
+	FullName keybase1.FullName `codec:"fullName" json:"fullName"`
+}
+
+func (o ChatMemberDetails) DeepCopy() ChatMemberDetails {
+	return ChatMemberDetails{
+		Uid:      o.Uid.DeepCopy(),
+		Username: o.Username,
+		FullName: o.FullName.DeepCopy(),
+	}
+}
+
+type ChatMembersDetails struct {
+	Owners         []ChatMemberDetails `codec:"owners" json:"owners"`
+	Admins         []ChatMemberDetails `codec:"admins" json:"admins"`
+	Writers        []ChatMemberDetails `codec:"writers" json:"writers"`
+	Readers        []ChatMemberDetails `codec:"readers" json:"readers"`
+	Bots           []ChatMemberDetails `codec:"bots" json:"bots"`
+	RestrictedBots []ChatMemberDetails `codec:"restrictedBots" json:"restrictedBots"`
+}
+
+func (o ChatMembersDetails) DeepCopy() ChatMembersDetails {
+	return ChatMembersDetails{
+		Owners: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Owners),
+		Admins: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Admins),
+		Writers: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Writers),
+		Readers: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Readers),
+		Bots: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Bots),
+		RestrictedBots: (func(x []ChatMemberDetails) []ChatMemberDetails {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChatMemberDetails, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RestrictedBots),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/emoji.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/emoji.go
new file mode 100644
index 00000000..6e756924
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/emoji.go
@@ -0,0 +1,374 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/chat1/emoji.avdl
+
+package chat1
+
+import (
+	"errors"
+	"fmt"
+
+	gregor1 "github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1"
+)
+
+type EmojiLoadSourceTyp int
+
+const (
+	EmojiLoadSourceTyp_HTTPSRV EmojiLoadSourceTyp = 0
+	EmojiLoadSourceTyp_STR     EmojiLoadSourceTyp = 1
+)
+
+func (o EmojiLoadSourceTyp) DeepCopy() EmojiLoadSourceTyp { return o }
+
+var EmojiLoadSourceTypMap = map[string]EmojiLoadSourceTyp{
+	"HTTPSRV": 0,
+	"STR":     1,
+}
+
+var EmojiLoadSourceTypRevMap = map[EmojiLoadSourceTyp]string{
+	0: "HTTPSRV",
+	1: "STR",
+}
+
+func (e EmojiLoadSourceTyp) String() string {
+	if v, ok := EmojiLoadSourceTypRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type EmojiLoadSource struct {
+	Typ__     EmojiLoadSourceTyp `codec:"typ" json:"typ"`
+	Httpsrv__ *string            `codec:"httpsrv,omitempty" json:"httpsrv,omitempty"`
+	Str__     *string            `codec:"str,omitempty" json:"str,omitempty"`
+}
+
+func (o *EmojiLoadSource) Typ() (ret EmojiLoadSourceTyp, err error) {
+	switch o.Typ__ {
+	case EmojiLoadSourceTyp_HTTPSRV:
+		if o.Httpsrv__ == nil {
+			err = errors.New("unexpected nil value for Httpsrv__")
+			return ret, err
+		}
+	case EmojiLoadSourceTyp_STR:
+		if o.Str__ == nil {
+			err = errors.New("unexpected nil value for Str__")
+			return ret, err
+		}
+	}
+	return o.Typ__, nil
+}
+
+func (o EmojiLoadSource) Httpsrv() (res string) {
+	if o.Typ__ != EmojiLoadSourceTyp_HTTPSRV {
+		panic("wrong case accessed")
+	}
+	if o.Httpsrv__ == nil {
+		return
+	}
+	return *o.Httpsrv__
+}
+
+func (o EmojiLoadSource) Str() (res string) {
+	if o.Typ__ != EmojiLoadSourceTyp_STR {
+		panic("wrong case accessed")
+	}
+	if o.Str__ == nil {
+		return
+	}
+	return *o.Str__
+}
+
+func NewEmojiLoadSourceWithHttpsrv(v string) EmojiLoadSource {
+	return EmojiLoadSource{
+		Typ__:     EmojiLoadSourceTyp_HTTPSRV,
+		Httpsrv__: &v,
+	}
+}
+
+func NewEmojiLoadSourceWithStr(v string) EmojiLoadSource {
+	return EmojiLoadSource{
+		Typ__: EmojiLoadSourceTyp_STR,
+		Str__: &v,
+	}
+}
+
+func (o EmojiLoadSource) DeepCopy() EmojiLoadSource {
+	return EmojiLoadSource{
+		Typ__: o.Typ__.DeepCopy(),
+		Httpsrv__: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Httpsrv__),
+		Str__: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Str__),
+	}
+}
+
+type EmojiRemoteSourceTyp int
+
+const (
+	EmojiRemoteSourceTyp_MESSAGE    EmojiRemoteSourceTyp = 0
+	EmojiRemoteSourceTyp_STOCKALIAS EmojiRemoteSourceTyp = 1
+)
+
+func (o EmojiRemoteSourceTyp) DeepCopy() EmojiRemoteSourceTyp { return o }
+
+var EmojiRemoteSourceTypMap = map[string]EmojiRemoteSourceTyp{
+	"MESSAGE":    0,
+	"STOCKALIAS": 1,
+}
+
+var EmojiRemoteSourceTypRevMap = map[EmojiRemoteSourceTyp]string{
+	0: "MESSAGE",
+	1: "STOCKALIAS",
+}
+
+func (e EmojiRemoteSourceTyp) String() string {
+	if v, ok := EmojiRemoteSourceTypRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type EmojiMessage struct {
+	ConvID  ConversationID `codec:"convID" json:"convID"`
+	MsgID   MessageID      `codec:"msgID" json:"msgID"`
+	IsAlias bool           `codec:"isAlias" json:"isAlias"`
+}
+
+func (o EmojiMessage) DeepCopy() EmojiMessage {
+	return EmojiMessage{
+		ConvID:  o.ConvID.DeepCopy(),
+		MsgID:   o.MsgID.DeepCopy(),
+		IsAlias: o.IsAlias,
+	}
+}
+
+type EmojiStockAlias struct {
+	Text     string       `codec:"text" json:"text"`
+	Username string       `codec:"username" json:"username"`
+	Time     gregor1.Time `codec:"time" json:"time"`
+}
+
+func (o EmojiStockAlias) DeepCopy() EmojiStockAlias {
+	return EmojiStockAlias{
+		Text:     o.Text,
+		Username: o.Username,
+		Time:     o.Time.DeepCopy(),
+	}
+}
+
+type EmojiRemoteSource struct {
+	Typ__        EmojiRemoteSourceTyp `codec:"typ" json:"typ"`
+	Message__    *EmojiMessage        `codec:"message,omitempty" json:"message,omitempty"`
+	Stockalias__ *EmojiStockAlias     `codec:"stockalias,omitempty" json:"stockalias,omitempty"`
+}
+
+func (o *EmojiRemoteSource) Typ() (ret EmojiRemoteSourceTyp, err error) {
+	switch o.Typ__ {
+	case EmojiRemoteSourceTyp_MESSAGE:
+		if o.Message__ == nil {
+			err = errors.New("unexpected nil value for Message__")
+			return ret, err
+		}
+	case EmojiRemoteSourceTyp_STOCKALIAS:
+		if o.Stockalias__ == nil {
+			err = errors.New("unexpected nil value for Stockalias__")
+			return ret, err
+		}
+	}
+	return o.Typ__, nil
+}
+
+func (o EmojiRemoteSource) Message() (res EmojiMessage) {
+	if o.Typ__ != EmojiRemoteSourceTyp_MESSAGE {
+		panic("wrong case accessed")
+	}
+	if o.Message__ == nil {
+		return
+	}
+	return *o.Message__
+}
+
+func (o EmojiRemoteSource) Stockalias() (res EmojiStockAlias) {
+	if o.Typ__ != EmojiRemoteSourceTyp_STOCKALIAS {
+		panic("wrong case accessed")
+	}
+	if o.Stockalias__ == nil {
+		return
+	}
+	return *o.Stockalias__
+}
+
+func NewEmojiRemoteSourceWithMessage(v EmojiMessage) EmojiRemoteSource {
+	return EmojiRemoteSource{
+		Typ__:     EmojiRemoteSourceTyp_MESSAGE,
+		Message__: &v,
+	}
+}
+
+func NewEmojiRemoteSourceWithStockalias(v EmojiStockAlias) EmojiRemoteSource {
+	return EmojiRemoteSource{
+		Typ__:        EmojiRemoteSourceTyp_STOCKALIAS,
+		Stockalias__: &v,
+	}
+}
+
+func (o EmojiRemoteSource) DeepCopy() EmojiRemoteSource {
+	return EmojiRemoteSource{
+		Typ__: o.Typ__.DeepCopy(),
+		Message__: (func(x *EmojiMessage) *EmojiMessage {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Message__),
+		Stockalias__: (func(x *EmojiStockAlias) *EmojiStockAlias {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Stockalias__),
+	}
+}
+
+type HarvestedEmoji struct {
+	Alias       string            `codec:"alias" json:"alias"`
+	IsBig       bool              `codec:"isBig" json:"isBig"`
+	IsCrossTeam bool              `codec:"isCrossTeam" json:"isCrossTeam"`
+	Source      EmojiRemoteSource `codec:"source" json:"source"`
+}
+
+func (o HarvestedEmoji) DeepCopy() HarvestedEmoji {
+	return HarvestedEmoji{
+		Alias:       o.Alias,
+		IsBig:       o.IsBig,
+		IsCrossTeam: o.IsCrossTeam,
+		Source:      o.Source.DeepCopy(),
+	}
+}
+
+type EmojiCreationInfo struct {
+	Username string       `codec:"username" json:"username"`
+	Time     gregor1.Time `codec:"time" json:"time"`
+}
+
+func (o EmojiCreationInfo) DeepCopy() EmojiCreationInfo {
+	return EmojiCreationInfo{
+		Username: o.Username,
+		Time:     o.Time.DeepCopy(),
+	}
+}
+
+type Emoji struct {
+	Alias        string             `codec:"alias" json:"alias"`
+	IsBig        bool               `codec:"isBig" json:"isBig"`
+	IsReacji     bool               `codec:"isReacji" json:"isReacji"`
+	IsCrossTeam  bool               `codec:"isCrossTeam" json:"isCrossTeam"`
+	IsAlias      bool               `codec:"isAlias" json:"isAlias"`
+	Source       EmojiLoadSource    `codec:"source" json:"source"`
+	NoAnimSource EmojiLoadSource    `codec:"noAnimSource" json:"noAnimSource"`
+	RemoteSource EmojiRemoteSource  `codec:"remoteSource" json:"remoteSource"`
+	CreationInfo *EmojiCreationInfo `codec:"creationInfo,omitempty" json:"creationInfo,omitempty"`
+	Teamname     *string            `codec:"teamname,omitempty" json:"teamname,omitempty"`
+}
+
+func (o Emoji) DeepCopy() Emoji {
+	return Emoji{
+		Alias:        o.Alias,
+		IsBig:        o.IsBig,
+		IsReacji:     o.IsReacji,
+		IsCrossTeam:  o.IsCrossTeam,
+		IsAlias:      o.IsAlias,
+		Source:       o.Source.DeepCopy(),
+		NoAnimSource: o.NoAnimSource.DeepCopy(),
+		RemoteSource: o.RemoteSource.DeepCopy(),
+		CreationInfo: (func(x *EmojiCreationInfo) *EmojiCreationInfo {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.CreationInfo),
+		Teamname: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Teamname),
+	}
+}
+
+type EmojiGroup struct {
+	Name   string  `codec:"name" json:"name"`
+	Emojis []Emoji `codec:"emojis" json:"emojis"`
+}
+
+func (o EmojiGroup) DeepCopy() EmojiGroup {
+	return EmojiGroup{
+		Name: o.Name,
+		Emojis: (func(x []Emoji) []Emoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]Emoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
+	}
+}
+
+type UserEmojis struct {
+	Emojis []EmojiGroup `codec:"emojis" json:"emojis"`
+}
+
+func (o UserEmojis) DeepCopy() UserEmojis {
+	return UserEmojis{
+		Emojis: (func(x []EmojiGroup) []EmojiGroup {
+			if x == nil {
+				return nil
+			}
+			ret := make([]EmojiGroup, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
+	}
+}
+
+type EmojiStorage struct {
+	Mapping map[string]EmojiRemoteSource `codec:"mapping" json:"mapping"`
+}
+
+func (o EmojiStorage) DeepCopy() EmojiStorage {
+	return EmojiStorage{
+		Mapping: (func(x map[string]EmojiRemoteSource) map[string]EmojiRemoteSource {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]EmojiRemoteSource, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Mapping),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/gregor.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/gregor.go
index 30e78484..01210c46 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/gregor.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/gregor.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/gregor.avdl
 
 package chat1
@@ -453,16 +453,6 @@ func (o UpdateConversations) DeepCopy() UpdateConversations {
 	}
 }
 
-type TeamChannelUpdate struct {
-	TeamID TLFID `codec:"teamID" json:"teamID"`
-}
-
-func (o TeamChannelUpdate) DeepCopy() TeamChannelUpdate {
-	return TeamChannelUpdate{
-		TeamID: o.TeamID.DeepCopy(),
-	}
-}
-
 type SetConvRetentionUpdate struct {
 	InboxVers InboxVers       `codec:"inboxVers" json:"inboxVers"`
 	ConvID    ConversationID  `codec:"convID" json:"convID"`
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/local.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/local.go
index d9ae8815..2f85c106 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/local.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/local.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/local.avdl
 
 package chat1
@@ -195,13 +195,14 @@ func (o LiveLocation) DeepCopy() LiveLocation {
 }
 
 type MessageText struct {
-	Body         string             `codec:"body" json:"body"`
-	Payments     []TextPayment      `codec:"payments" json:"payments"`
-	ReplyTo      *MessageID         `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
-	ReplyToUID   *gregor1.UID       `codec:"replyToUID,omitempty" json:"replyToUID,omitempty"`
-	UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"`
-	TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"`
-	LiveLocation *LiveLocation      `codec:"liveLocation,omitempty" json:"liveLocation,omitempty"`
+	Body         string                    `codec:"body" json:"body"`
+	Payments     []TextPayment             `codec:"payments" json:"payments"`
+	ReplyTo      *MessageID                `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
+	ReplyToUID   *gregor1.UID              `codec:"replyToUID,omitempty" json:"replyToUID,omitempty"`
+	UserMentions []KnownUserMention        `codec:"userMentions" json:"userMentions"`
+	TeamMentions []KnownTeamMention        `codec:"teamMentions" json:"teamMentions"`
+	LiveLocation *LiveLocation             `codec:"liveLocation,omitempty" json:"liveLocation,omitempty"`
+	Emojis       map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageText) DeepCopy() MessageText {
@@ -261,6 +262,18 @@ func (o MessageText) DeepCopy() MessageText {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.LiveLocation),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -275,10 +288,11 @@ func (o MessageConversationMetadata) DeepCopy() MessageConversationMetadata {
 }
 
 type MessageEdit struct {
-	MessageID    MessageID          `codec:"messageID" json:"messageID"`
-	Body         string             `codec:"body" json:"body"`
-	UserMentions []KnownUserMention `codec:"userMentions" json:"userMentions"`
-	TeamMentions []KnownTeamMention `codec:"teamMentions" json:"teamMentions"`
+	MessageID    MessageID                 `codec:"messageID" json:"messageID"`
+	Body         string                    `codec:"body" json:"body"`
+	UserMentions []KnownUserMention        `codec:"userMentions" json:"userMentions"`
+	TeamMentions []KnownTeamMention        `codec:"teamMentions" json:"teamMentions"`
+	Emojis       map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageEdit) DeepCopy() MessageEdit {
@@ -307,6 +321,18 @@ func (o MessageEdit) DeepCopy() MessageEdit {
 			}
 			return ret
 		})(o.TeamMentions),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -331,12 +357,25 @@ func (o MessageDelete) DeepCopy() MessageDelete {
 }
 
 type MessageHeadline struct {
-	Headline string `codec:"headline" json:"headline"`
+	Headline string                    `codec:"headline" json:"headline"`
+	Emojis   map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageHeadline) DeepCopy() MessageHeadline {
 	return MessageHeadline{
 		Headline: o.Headline,
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -400,6 +439,7 @@ const (
 	MessageSystemType_CHANGERETENTION   MessageSystemType = 6
 	MessageSystemType_BULKADDTOCONV     MessageSystemType = 7
 	MessageSystemType_SBSRESOLVE        MessageSystemType = 8
+	MessageSystemType_NEWCHANNEL        MessageSystemType = 9
 )
 
 func (o MessageSystemType) DeepCopy() MessageSystemType { return o }
@@ -414,6 +454,7 @@ var MessageSystemTypeMap = map[string]MessageSystemType{
 	"CHANGERETENTION":   6,
 	"BULKADDTOCONV":     7,
 	"SBSRESOLVE":        8,
+	"NEWCHANNEL":        9,
 }
 
 var MessageSystemTypeRevMap = map[MessageSystemType]string{
@@ -426,6 +467,7 @@ var MessageSystemTypeRevMap = map[MessageSystemType]string{
 	6: "CHANGERETENTION",
 	7: "BULKADDTOCONV",
 	8: "SBSRESOLVE",
+	9: "NEWCHANNEL",
 }
 
 func (e MessageSystemType) String() string {
@@ -436,17 +478,11 @@ func (e MessageSystemType) String() string {
 }
 
 type MessageSystemAddedToTeam struct {
-	Team           string            `codec:"team" json:"team"`
-	Adder          string            `codec:"adder" json:"adder"`
-	Addee          string            `codec:"addee" json:"addee"`
-	Role           keybase1.TeamRole `codec:"role" json:"role"`
-	BulkAdds       []string          `codec:"bulkAdds" json:"bulkAdds"`
-	Owners         []string          `codec:"owners" json:"owners"`
-	Admins         []string          `codec:"admins" json:"admins"`
-	Writers        []string          `codec:"writers" json:"writers"`
-	Readers        []string          `codec:"readers" json:"readers"`
-	Bots           []string          `codec:"bots" json:"bots"`
-	RestrictedBots []string          `codec:"restrictedBots" json:"restrictedBots"`
+	Team     string            `codec:"team" json:"team"`
+	Adder    string            `codec:"adder" json:"adder"`
+	Addee    string            `codec:"addee" json:"addee"`
+	Role     keybase1.TeamRole `codec:"role" json:"role"`
+	BulkAdds []string          `codec:"bulkAdds" json:"bulkAdds"`
 }
 
 func (o MessageSystemAddedToTeam) DeepCopy() MessageSystemAddedToTeam {
@@ -466,72 +502,6 @@ func (o MessageSystemAddedToTeam) DeepCopy() MessageSystemAddedToTeam {
 			}
 			return ret
 		})(o.BulkAdds),
-		Owners: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Owners),
-		Admins: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Admins),
-		Writers: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Writers),
-		Readers: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Readers),
-		Bots: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Bots),
-		RestrictedBots: (func(x []string) []string {
-			if x == nil {
-				return nil
-			}
-			ret := make([]string, len(x))
-			for i, v := range x {
-				vCopy := v
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.RestrictedBots),
 	}
 }
 
@@ -673,6 +643,32 @@ func (o MessageSystemSbsResolve) DeepCopy() MessageSystemSbsResolve {
 	}
 }
 
+type MessageSystemNewChannel struct {
+	Creator        string           `codec:"creator" json:"creator"`
+	NameAtCreation string           `codec:"nameAtCreation" json:"nameAtCreation"`
+	ConvID         ConversationID   `codec:"convID" json:"convID"`
+	ConvIDs        []ConversationID `codec:"convIDs" json:"convIDs"`
+}
+
+func (o MessageSystemNewChannel) DeepCopy() MessageSystemNewChannel {
+	return MessageSystemNewChannel{
+		Creator:        o.Creator,
+		NameAtCreation: o.NameAtCreation,
+		ConvID:         o.ConvID.DeepCopy(),
+		ConvIDs: (func(x []ConversationID) []ConversationID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ConversationID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.ConvIDs),
+	}
+}
+
 type MessageSystem struct {
 	SystemType__        MessageSystemType               `codec:"systemType" json:"systemType"`
 	Addedtoteam__       *MessageSystemAddedToTeam       `codec:"addedtoteam,omitempty" json:"addedtoteam,omitempty"`
@@ -684,6 +680,7 @@ type MessageSystem struct {
 	Changeretention__   *MessageSystemChangeRetention   `codec:"changeretention,omitempty" json:"changeretention,omitempty"`
 	Bulkaddtoconv__     *MessageSystemBulkAddToConv     `codec:"bulkaddtoconv,omitempty" json:"bulkaddtoconv,omitempty"`
 	Sbsresolve__        *MessageSystemSbsResolve        `codec:"sbsresolve,omitempty" json:"sbsresolve,omitempty"`
+	Newchannel__        *MessageSystemNewChannel        `codec:"newchannel,omitempty" json:"newchannel,omitempty"`
 }
 
 func (o *MessageSystem) SystemType() (ret MessageSystemType, err error) {
@@ -733,6 +730,11 @@ func (o *MessageSystem) SystemType() (ret MessageSystemType, err error) {
 			err = errors.New("unexpected nil value for Sbsresolve__")
 			return ret, err
 		}
+	case MessageSystemType_NEWCHANNEL:
+		if o.Newchannel__ == nil {
+			err = errors.New("unexpected nil value for Newchannel__")
+			return ret, err
+		}
 	}
 	return o.SystemType__, nil
 }
@@ -827,6 +829,16 @@ func (o MessageSystem) Sbsresolve() (res MessageSystemSbsResolve) {
 	return *o.Sbsresolve__
 }
 
+func (o MessageSystem) Newchannel() (res MessageSystemNewChannel) {
+	if o.SystemType__ != MessageSystemType_NEWCHANNEL {
+		panic("wrong case accessed")
+	}
+	if o.Newchannel__ == nil {
+		return
+	}
+	return *o.Newchannel__
+}
+
 func NewMessageSystemWithAddedtoteam(v MessageSystemAddedToTeam) MessageSystem {
 	return MessageSystem{
 		SystemType__:  MessageSystemType_ADDEDTOTEAM,
@@ -890,6 +902,13 @@ func NewMessageSystemWithSbsresolve(v MessageSystemSbsResolve) MessageSystem {
 	}
 }
 
+func NewMessageSystemWithNewchannel(v MessageSystemNewChannel) MessageSystem {
+	return MessageSystem{
+		SystemType__: MessageSystemType_NEWCHANNEL,
+		Newchannel__: &v,
+	}
+}
+
 func (o MessageSystem) DeepCopy() MessageSystem {
 	return MessageSystem{
 		SystemType__: o.SystemType__.DeepCopy(),
@@ -956,6 +975,13 @@ func (o MessageSystem) DeepCopy() MessageSystem {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.Sbsresolve__),
+		Newchannel__: (func(x *MessageSystemNewChannel) *MessageSystemNewChannel {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Newchannel__),
 	}
 }
 
@@ -970,11 +996,14 @@ func (o MessageDeleteHistory) DeepCopy() MessageDeleteHistory {
 }
 
 type MessageAttachment struct {
-	Object   Asset   `codec:"object" json:"object"`
-	Preview  *Asset  `codec:"preview,omitempty" json:"preview,omitempty"`
-	Previews []Asset `codec:"previews" json:"previews"`
-	Metadata []byte  `codec:"metadata" json:"metadata"`
-	Uploaded bool    `codec:"uploaded" json:"uploaded"`
+	Object       Asset                     `codec:"object" json:"object"`
+	Preview      *Asset                    `codec:"preview,omitempty" json:"preview,omitempty"`
+	Previews     []Asset                   `codec:"previews" json:"previews"`
+	Metadata     []byte                    `codec:"metadata" json:"metadata"`
+	Uploaded     bool                      `codec:"uploaded" json:"uploaded"`
+	UserMentions []KnownUserMention        `codec:"userMentions" json:"userMentions"`
+	TeamMentions []KnownTeamMention        `codec:"teamMentions" json:"teamMentions"`
+	Emojis       map[string]HarvestedEmoji `codec:"emojis" json:"emojis"`
 }
 
 func (o MessageAttachment) DeepCopy() MessageAttachment {
@@ -1005,6 +1034,40 @@ func (o MessageAttachment) DeepCopy() MessageAttachment {
 			return append([]byte{}, x...)
 		})(o.Metadata),
 		Uploaded: o.Uploaded,
+		UserMentions: (func(x []KnownUserMention) []KnownUserMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]KnownUserMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.UserMentions),
+		TeamMentions: (func(x []KnownTeamMention) []KnownTeamMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]KnownTeamMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.TeamMentions),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -1079,14 +1142,35 @@ func (o MessageLeave) DeepCopy() MessageLeave {
 }
 
 type MessageReaction struct {
-	MessageID MessageID `codec:"m" json:"m"`
-	Body      string    `codec:"b" json:"b"`
+	MessageID MessageID                 `codec:"m" json:"m"`
+	Body      string                    `codec:"b" json:"b"`
+	TargetUID *gregor1.UID              `codec:"t,omitempty" json:"t,omitempty"`
+	Emojis    map[string]HarvestedEmoji `codec:"e" json:"e"`
 }
 
 func (o MessageReaction) DeepCopy() MessageReaction {
 	return MessageReaction{
 		MessageID: o.MessageID.DeepCopy(),
 		Body:      o.Body,
+		TargetUID: (func(x *gregor1.UID) *gregor1.UID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.TargetUID),
+		Emojis: (func(x map[string]HarvestedEmoji) map[string]HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]HarvestedEmoji, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -2793,6 +2877,7 @@ type MessagePlaintext struct {
 	ClientHeader       MessageClientHeader `codec:"clientHeader" json:"clientHeader"`
 	MessageBody        MessageBody         `codec:"messageBody" json:"messageBody"`
 	SupersedesOutboxID *OutboxID           `codec:"supersedesOutboxID,omitempty" json:"supersedesOutboxID,omitempty"`
+	Emojis             []HarvestedEmoji    `codec:"emojis" json:"emojis"`
 }
 
 func (o MessagePlaintext) DeepCopy() MessagePlaintext {
@@ -2806,6 +2891,17 @@ func (o MessagePlaintext) DeepCopy() MessagePlaintext {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.SupersedesOutboxID),
+		Emojis: (func(x []HarvestedEmoji) []HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]HarvestedEmoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 	}
 }
 
@@ -2815,7 +2911,7 @@ type MessageUnboxedValid struct {
 	MessageBody           MessageBody                 `codec:"messageBody" json:"messageBody"`
 	SenderUsername        string                      `codec:"senderUsername" json:"senderUsername"`
 	SenderDeviceName      string                      `codec:"senderDeviceName" json:"senderDeviceName"`
-	SenderDeviceType      string                      `codec:"senderDeviceType" json:"senderDeviceType"`
+	SenderDeviceType      keybase1.DeviceTypeV2       `codec:"senderDeviceType" json:"senderDeviceType"`
 	BodyHash              Hash                        `codec:"bodyHash" json:"bodyHash"`
 	HeaderHash            Hash                        `codec:"headerHash" json:"headerHash"`
 	HeaderSignature       *SignatureInfo              `codec:"headerSignature,omitempty" json:"headerSignature,omitempty"`
@@ -2828,6 +2924,7 @@ type MessageUnboxedValid struct {
 	ChannelNameMentions   []ChannelNameMention        `codec:"channelNameMentions" json:"channelNameMentions"`
 	Reactions             ReactionMap                 `codec:"reactions" json:"reactions"`
 	Unfurls               map[MessageID]UnfurlResult  `codec:"unfurls" json:"unfurls"`
+	Emojis                []HarvestedEmoji            `codec:"emojis" json:"emojis"`
 	ReplyTo               *MessageUnboxed             `codec:"replyTo,omitempty" json:"replyTo,omitempty"`
 	BotUsername           string                      `codec:"botUsername" json:"botUsername"`
 }
@@ -2839,7 +2936,7 @@ func (o MessageUnboxedValid) DeepCopy() MessageUnboxedValid {
 		MessageBody:      o.MessageBody.DeepCopy(),
 		SenderUsername:   o.SenderUsername,
 		SenderDeviceName: o.SenderDeviceName,
-		SenderDeviceType: o.SenderDeviceType,
+		SenderDeviceType: o.SenderDeviceType.DeepCopy(),
 		BodyHash:         o.BodyHash.DeepCopy(),
 		HeaderHash:       o.HeaderHash.DeepCopy(),
 		HeaderSignature: (func(x *SignatureInfo) *SignatureInfo {
@@ -2926,6 +3023,17 @@ func (o MessageUnboxedValid) DeepCopy() MessageUnboxedValid {
 			}
 			return ret
 		})(o.Unfurls),
+		Emojis: (func(x []HarvestedEmoji) []HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]HarvestedEmoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Emojis),
 		ReplyTo: (func(x *MessageUnboxed) *MessageUnboxed {
 			if x == nil {
 				return nil
@@ -2984,7 +3092,7 @@ type MessageUnboxedError struct {
 	IsCritical       bool                    `codec:"isCritical" json:"isCritical"`
 	SenderUsername   string                  `codec:"senderUsername" json:"senderUsername"`
 	SenderDeviceName string                  `codec:"senderDeviceName" json:"senderDeviceName"`
-	SenderDeviceType string                  `codec:"senderDeviceType" json:"senderDeviceType"`
+	SenderDeviceType keybase1.DeviceTypeV2   `codec:"senderDeviceType" json:"senderDeviceType"`
 	MessageID        MessageID               `codec:"messageID" json:"messageID"`
 	MessageType      MessageType             `codec:"messageType" json:"messageType"`
 	Ctime            gregor1.Time            `codec:"ctime" json:"ctime"`
@@ -3004,7 +3112,7 @@ func (o MessageUnboxedError) DeepCopy() MessageUnboxedError {
 		IsCritical:       o.IsCritical,
 		SenderUsername:   o.SenderUsername,
 		SenderDeviceName: o.SenderDeviceName,
-		SenderDeviceType: o.SenderDeviceType,
+		SenderDeviceType: o.SenderDeviceType.DeepCopy(),
 		MessageID:        o.MessageID.DeepCopy(),
 		MessageType:      o.MessageType.DeepCopy(),
 		Ctime:            o.Ctime.DeepCopy(),
@@ -3316,26 +3424,27 @@ func (o ConversationPinnedMessage) DeepCopy() ConversationPinnedMessage {
 }
 
 type ConversationInfoLocal struct {
-	Id            ConversationID                 `codec:"id" json:"id"`
-	Triple        ConversationIDTriple           `codec:"triple" json:"triple"`
-	TlfName       string                         `codec:"tlfName" json:"tlfName"`
-	TopicName     string                         `codec:"topicName" json:"topicName"`
-	Headline      string                         `codec:"headline" json:"headline"`
-	SnippetMsg    *MessageUnboxed                `codec:"snippetMsg,omitempty" json:"snippetMsg,omitempty"`
-	PinnedMsg     *ConversationPinnedMessage     `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"`
-	Draft         *string                        `codec:"draft,omitempty" json:"draft,omitempty"`
-	Visibility    keybase1.TLFVisibility         `codec:"visibility" json:"visibility"`
-	IsDefaultConv bool                           `codec:"isDefaultConv" json:"isDefaultConv"`
-	Status        ConversationStatus             `codec:"status" json:"status"`
-	MembersType   ConversationMembersType        `codec:"membersType" json:"membersType"`
-	MemberStatus  ConversationMemberStatus       `codec:"memberStatus" json:"memberStatus"`
-	TeamType      TeamType                       `codec:"teamType" json:"teamType"`
-	Existence     ConversationExistence          `codec:"existence" json:"existence"`
-	Version       ConversationVers               `codec:"version" json:"version"`
-	LocalVersion  LocalConversationVers          `codec:"localVersion" json:"localVersion"`
-	Participants  []ConversationLocalParticipant `codec:"participants" json:"participants"`
-	FinalizeInfo  *ConversationFinalizeInfo      `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"`
-	ResetNames    []string                       `codec:"resetNames" json:"resetNames"`
+	Id             ConversationID                 `codec:"id" json:"id"`
+	Triple         ConversationIDTriple           `codec:"triple" json:"triple"`
+	TlfName        string                         `codec:"tlfName" json:"tlfName"`
+	TopicName      string                         `codec:"topicName" json:"topicName"`
+	Headline       string                         `codec:"headline" json:"headline"`
+	HeadlineEmojis []HarvestedEmoji               `codec:"headlineEmojis" json:"headlineEmojis"`
+	SnippetMsg     *MessageUnboxed                `codec:"snippetMsg,omitempty" json:"snippetMsg,omitempty"`
+	PinnedMsg      *ConversationPinnedMessage     `codec:"pinnedMsg,omitempty" json:"pinnedMsg,omitempty"`
+	Draft          *string                        `codec:"draft,omitempty" json:"draft,omitempty"`
+	Visibility     keybase1.TLFVisibility         `codec:"visibility" json:"visibility"`
+	IsDefaultConv  bool                           `codec:"isDefaultConv" json:"isDefaultConv"`
+	Status         ConversationStatus             `codec:"status" json:"status"`
+	MembersType    ConversationMembersType        `codec:"membersType" json:"membersType"`
+	MemberStatus   ConversationMemberStatus       `codec:"memberStatus" json:"memberStatus"`
+	TeamType       TeamType                       `codec:"teamType" json:"teamType"`
+	Existence      ConversationExistence          `codec:"existence" json:"existence"`
+	Version        ConversationVers               `codec:"version" json:"version"`
+	LocalVersion   LocalConversationVers          `codec:"localVersion" json:"localVersion"`
+	Participants   []ConversationLocalParticipant `codec:"participants" json:"participants"`
+	FinalizeInfo   *ConversationFinalizeInfo      `codec:"finalizeInfo,omitempty" json:"finalizeInfo,omitempty"`
+	ResetNames     []string                       `codec:"resetNames" json:"resetNames"`
 }
 
 func (o ConversationInfoLocal) DeepCopy() ConversationInfoLocal {
@@ -3345,6 +3454,17 @@ func (o ConversationInfoLocal) DeepCopy() ConversationInfoLocal {
 		TlfName:   o.TlfName,
 		TopicName: o.TopicName,
 		Headline:  o.Headline,
+		HeadlineEmojis: (func(x []HarvestedEmoji) []HarvestedEmoji {
+			if x == nil {
+				return nil
+			}
+			ret := make([]HarvestedEmoji, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.HeadlineEmojis),
 		SnippetMsg: (func(x *MessageUnboxed) *MessageUnboxed {
 			if x == nil {
 				return nil
@@ -4343,6 +4463,98 @@ func (o SetConversationStatusLocalRes) DeepCopy() SetConversationStatusLocalRes
 	}
 }
 
+type NewConversationsLocalRes struct {
+	Results          []NewConversationsLocalResult `codec:"results" json:"results"`
+	RateLimits       []RateLimit                   `codec:"rateLimits" json:"rateLimits"`
+	IdentifyFailures []keybase1.TLFIdentifyFailure `codec:"identifyFailures" json:"identifyFailures"`
+}
+
+func (o NewConversationsLocalRes) DeepCopy() NewConversationsLocalRes {
+	return NewConversationsLocalRes{
+		Results: (func(x []NewConversationsLocalResult) []NewConversationsLocalResult {
+			if x == nil {
+				return nil
+			}
+			ret := make([]NewConversationsLocalResult, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Results),
+		RateLimits: (func(x []RateLimit) []RateLimit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RateLimit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RateLimits),
+		IdentifyFailures: (func(x []keybase1.TLFIdentifyFailure) []keybase1.TLFIdentifyFailure {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.TLFIdentifyFailure, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.IdentifyFailures),
+	}
+}
+
+type NewConversationsLocalResult struct {
+	Result *NewConversationLocalRes `codec:"result,omitempty" json:"result,omitempty"`
+	Err    *string                  `codec:"err,omitempty" json:"err,omitempty"`
+}
+
+func (o NewConversationsLocalResult) DeepCopy() NewConversationsLocalResult {
+	return NewConversationsLocalResult{
+		Result: (func(x *NewConversationLocalRes) *NewConversationLocalRes {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Result),
+		Err: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Err),
+	}
+}
+
+type NewConversationLocalArgument struct {
+	TlfName       string                  `codec:"tlfName" json:"tlfName"`
+	TopicType     TopicType               `codec:"topicType" json:"topicType"`
+	TlfVisibility keybase1.TLFVisibility  `codec:"tlfVisibility" json:"tlfVisibility"`
+	TopicName     *string                 `codec:"topicName,omitempty" json:"topicName,omitempty"`
+	MembersType   ConversationMembersType `codec:"membersType" json:"membersType"`
+}
+
+func (o NewConversationLocalArgument) DeepCopy() NewConversationLocalArgument {
+	return NewConversationLocalArgument{
+		TlfName:       o.TlfName,
+		TopicType:     o.TopicType.DeepCopy(),
+		TlfVisibility: o.TlfVisibility.DeepCopy(),
+		TopicName: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.TopicName),
+		MembersType: o.MembersType.DeepCopy(),
+	}
+}
+
 type NewConversationLocalRes struct {
 	Conv             ConversationLocal             `codec:"conv" json:"conv"`
 	UiConv           InboxUIItem                   `codec:"uiConv" json:"uiConv"`
@@ -5098,6 +5310,74 @@ func (o GetTLFConversationsLocalRes) DeepCopy() GetTLFConversationsLocalRes {
 	}
 }
 
+type GetChannelMembershipsLocalRes struct {
+	Channels   []ChannelNameMention `codec:"channels" json:"channels"`
+	Offline    bool                 `codec:"offline" json:"offline"`
+	RateLimits []RateLimit          `codec:"rateLimits" json:"rateLimits"`
+}
+
+func (o GetChannelMembershipsLocalRes) DeepCopy() GetChannelMembershipsLocalRes {
+	return GetChannelMembershipsLocalRes{
+		Channels: (func(x []ChannelNameMention) []ChannelNameMention {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ChannelNameMention, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Channels),
+		Offline: o.Offline,
+		RateLimits: (func(x []RateLimit) []RateLimit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RateLimit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RateLimits),
+	}
+}
+
+type GetMutualTeamsLocalRes struct {
+	TeamIDs    []keybase1.TeamID `codec:"teamIDs" json:"teamIDs"`
+	Offline    bool              `codec:"offline" json:"offline"`
+	RateLimits []RateLimit       `codec:"rateLimits" json:"rateLimits"`
+}
+
+func (o GetMutualTeamsLocalRes) DeepCopy() GetMutualTeamsLocalRes {
+	return GetMutualTeamsLocalRes{
+		TeamIDs: (func(x []keybase1.TeamID) []keybase1.TeamID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]keybase1.TeamID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.TeamIDs),
+		Offline: o.Offline,
+		RateLimits: (func(x []RateLimit) []RateLimit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RateLimit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.RateLimits),
+	}
+}
+
 type SetAppNotificationSettingsLocalRes struct {
 	Offline    bool        `codec:"offline" json:"offline"`
 	RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"`
@@ -5268,6 +5548,34 @@ func (o SearchInboxRes) DeepCopy() SearchInboxRes {
 	}
 }
 
+type SimpleSearchInboxConvNamesHit struct {
+	Name    string         `codec:"name" json:"name"`
+	ConvID  ConversationID `codec:"convID" json:"convID"`
+	IsTeam  bool           `codec:"isTeam" json:"isTeam"`
+	Parts   []string       `codec:"parts" json:"parts"`
+	TlfName string         `codec:"tlfName" json:"tlfName"`
+}
+
+func (o SimpleSearchInboxConvNamesHit) DeepCopy() SimpleSearchInboxConvNamesHit {
+	return SimpleSearchInboxConvNamesHit{
+		Name:   o.Name,
+		ConvID: o.ConvID.DeepCopy(),
+		IsTeam: o.IsTeam,
+		Parts: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Parts),
+		TlfName: o.TlfName,
+	}
+}
+
 type ProfileSearchConvStats struct {
 	Err            string               `codec:"err" json:"err"`
 	ConvName       string               `codec:"convName" json:"convName"`
@@ -5652,6 +5960,7 @@ type AdvertiseCommandsParam struct {
 	Typ      BotCommandsAdvertisementTyp `codec:"typ" json:"typ"`
 	Commands []UserBotCommandInput       `codec:"commands" json:"commands"`
 	TeamName *string                     `codec:"teamName,omitempty" json:"teamName,omitempty"`
+	ConvID   *ConversationID             `codec:"convID,omitempty" json:"convID,omitempty"`
 }
 
 func (o AdvertiseCommandsParam) DeepCopy() AdvertiseCommandsParam {
@@ -5675,6 +5984,13 @@ func (o AdvertiseCommandsParam) DeepCopy() AdvertiseCommandsParam {
 			tmp := (*x)
 			return &tmp
 		})(o.TeamName),
+		ConvID: (func(x *ConversationID) *ConversationID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ConvID),
 	}
 }
 
@@ -5730,6 +6046,32 @@ func (o ListBotCommandsLocalRes) DeepCopy() ListBotCommandsLocalRes {
 	}
 }
 
+type ClearBotCommandsFilter struct {
+	Typ      BotCommandsAdvertisementTyp `codec:"typ" json:"typ"`
+	TeamName *string                     `codec:"teamName,omitempty" json:"teamName,omitempty"`
+	ConvID   *ConversationID             `codec:"convID,omitempty" json:"convID,omitempty"`
+}
+
+func (o ClearBotCommandsFilter) DeepCopy() ClearBotCommandsFilter {
+	return ClearBotCommandsFilter{
+		Typ: o.Typ.DeepCopy(),
+		TeamName: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.TeamName),
+		ConvID: (func(x *ConversationID) *ConversationID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.ConvID),
+	}
+}
+
 type ClearBotCommandsLocalRes struct {
 	RateLimits []RateLimit `codec:"rateLimits" json:"rateLimits"`
 }
@@ -5863,3 +6205,290 @@ func (e SnippetDecoration) String() string {
 	}
 	return fmt.Sprintf("%v", int(e))
 }
+
+type WelcomeMessageDisplay struct {
+	Set     bool   `codec:"set" json:"set"`
+	Display string `codec:"display" json:"display"`
+	Raw     string `codec:"raw" json:"raw"`
+}
+
+func (o WelcomeMessageDisplay) DeepCopy() WelcomeMessageDisplay {
+	return WelcomeMessageDisplay{
+		Set:     o.Set,
+		Display: o.Display,
+		Raw:     o.Raw,
+	}
+}
+
+type WelcomeMessage struct {
+	Set bool   `codec:"set" json:"set"`
+	Raw string `codec:"raw" json:"raw"`
+}
+
+func (o WelcomeMessage) DeepCopy() WelcomeMessage {
+	return WelcomeMessage{
+		Set: o.Set,
+		Raw: o.Raw,
+	}
+}
+
+type GetDefaultTeamChannelsLocalRes struct {
+	Convs     []InboxUIItem `codec:"convs" json:"convs"`
+	RateLimit *RateLimit    `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetDefaultTeamChannelsLocalRes) DeepCopy() GetDefaultTeamChannelsLocalRes {
+	return GetDefaultTeamChannelsLocalRes{
+		Convs: (func(x []InboxUIItem) []InboxUIItem {
+			if x == nil {
+				return nil
+			}
+			ret := make([]InboxUIItem, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Convs),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type SetDefaultTeamChannelsLocalRes struct {
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o SetDefaultTeamChannelsLocalRes) DeepCopy() SetDefaultTeamChannelsLocalRes {
+	return SetDefaultTeamChannelsLocalRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type LastActiveTimeAll struct {
+	Teams    map[TLFIDStr]gregor1.Time  `codec:"teams" json:"teams"`
+	Channels map[ConvIDStr]gregor1.Time `codec:"channels" json:"channels"`
+}
+
+func (o LastActiveTimeAll) DeepCopy() LastActiveTimeAll {
+	return LastActiveTimeAll{
+		Teams: (func(x map[TLFIDStr]gregor1.Time) map[TLFIDStr]gregor1.Time {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[TLFIDStr]gregor1.Time, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Teams),
+		Channels: (func(x map[ConvIDStr]gregor1.Time) map[ConvIDStr]gregor1.Time {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[ConvIDStr]gregor1.Time, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Channels),
+	}
+}
+
+type LastActiveStatusAll struct {
+	Teams    map[TLFIDStr]LastActiveStatus  `codec:"teams" json:"teams"`
+	Channels map[ConvIDStr]LastActiveStatus `codec:"channels" json:"channels"`
+}
+
+func (o LastActiveStatusAll) DeepCopy() LastActiveStatusAll {
+	return LastActiveStatusAll{
+		Teams: (func(x map[TLFIDStr]LastActiveStatus) map[TLFIDStr]LastActiveStatus {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[TLFIDStr]LastActiveStatus, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Teams),
+		Channels: (func(x map[ConvIDStr]LastActiveStatus) map[ConvIDStr]LastActiveStatus {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[ConvIDStr]LastActiveStatus, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Channels),
+	}
+}
+
+type EmojiError struct {
+	Clidisplay string `codec:"clidisplay" json:"clidisplay"`
+	Uidisplay  string `codec:"uidisplay" json:"uidisplay"`
+}
+
+func (o EmojiError) DeepCopy() EmojiError {
+	return EmojiError{
+		Clidisplay: o.Clidisplay,
+		Uidisplay:  o.Uidisplay,
+	}
+}
+
+type AddEmojiRes struct {
+	RateLimit *RateLimit  `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	Error     *EmojiError `codec:"error,omitempty" json:"error,omitempty"`
+}
+
+func (o AddEmojiRes) DeepCopy() AddEmojiRes {
+	return AddEmojiRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+		Error: (func(x *EmojiError) *EmojiError {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Error),
+	}
+}
+
+type AddEmojisRes struct {
+	RateLimit        *RateLimit            `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	SuccessFilenames []string              `codec:"successFilenames" json:"successFilenames"`
+	FailedFilenames  map[string]EmojiError `codec:"failedFilenames" json:"failedFilenames"`
+}
+
+func (o AddEmojisRes) DeepCopy() AddEmojisRes {
+	return AddEmojisRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+		SuccessFilenames: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.SuccessFilenames),
+		FailedFilenames: (func(x map[string]EmojiError) map[string]EmojiError {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]EmojiError, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.FailedFilenames),
+	}
+}
+
+type AddEmojiAliasRes struct {
+	RateLimit *RateLimit  `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	Error     *EmojiError `codec:"error,omitempty" json:"error,omitempty"`
+}
+
+func (o AddEmojiAliasRes) DeepCopy() AddEmojiAliasRes {
+	return AddEmojiAliasRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+		Error: (func(x *EmojiError) *EmojiError {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Error),
+	}
+}
+
+type RemoveEmojiRes struct {
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o RemoveEmojiRes) DeepCopy() RemoveEmojiRes {
+	return RemoveEmojiRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type UserEmojiRes struct {
+	Emojis    UserEmojis `codec:"emojis" json:"emojis"`
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o UserEmojiRes) DeepCopy() UserEmojiRes {
+	return UserEmojiRes{
+		Emojis: o.Emojis.DeepCopy(),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type EmojiFetchOpts struct {
+	GetCreationInfo bool `codec:"getCreationInfo" json:"getCreationInfo"`
+	GetAliases      bool `codec:"getAliases" json:"getAliases"`
+	OnlyInTeam      bool `codec:"onlyInTeam" json:"onlyInTeam"`
+}
+
+func (o EmojiFetchOpts) DeepCopy() EmojiFetchOpts {
+	return EmojiFetchOpts{
+		GetCreationInfo: o.GetCreationInfo,
+		GetAliases:      o.GetAliases,
+		OnlyInTeam:      o.OnlyInTeam,
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/notify.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/notify.go
index ebc5c2a2..7d4ba74e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/notify.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/notify.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/notify.avdl
 
 package chat1
@@ -115,7 +115,7 @@ func (o IncomingMessage) DeepCopy() IncomingMessage {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.ModifiedMessage),
-		ConvID:                     o.ConvID.DeepCopy(),
+		ConvID: o.ConvID.DeepCopy(),
 		DisplayDesktopNotification: o.DisplayDesktopNotification,
 		DesktopNotificationSnippet: o.DesktopNotificationSnippet,
 		Conv: (func(x *InboxUIItem) *InboxUIItem {
@@ -324,8 +324,8 @@ func (o EphemeralPurgeNotifInfo) DeepCopy() EphemeralPurgeNotifInfo {
 }
 
 type ReactionUpdate struct {
-	Reactions   ReactionMap `codec:"reactions" json:"reactions"`
-	TargetMsgID MessageID   `codec:"targetMsgID" json:"targetMsgID"`
+	Reactions   UIReactionMap `codec:"reactions" json:"reactions"`
+	TargetMsgID MessageID     `codec:"targetMsgID" json:"targetMsgID"`
 }
 
 func (o ReactionUpdate) DeepCopy() ReactionUpdate {
@@ -758,20 +758,16 @@ func (o ChatActivity) DeepCopy() ChatActivity {
 }
 
 type TyperInfo struct {
-	Uid        keybase1.UID      `codec:"uid" json:"uid"`
-	Username   string            `codec:"username" json:"username"`
-	DeviceID   keybase1.DeviceID `codec:"deviceID" json:"deviceID"`
-	DeviceName string            `codec:"deviceName" json:"deviceName"`
-	DeviceType string            `codec:"deviceType" json:"deviceType"`
+	Uid      keybase1.UID      `codec:"uid" json:"uid"`
+	Username string            `codec:"username" json:"username"`
+	DeviceID keybase1.DeviceID `codec:"deviceID" json:"deviceID"`
 }
 
 func (o TyperInfo) DeepCopy() TyperInfo {
 	return TyperInfo{
-		Uid:        o.Uid.DeepCopy(),
-		Username:   o.Username,
-		DeviceID:   o.DeviceID.DeepCopy(),
-		DeviceName: o.DeviceName,
-		DeviceType: o.DeviceType,
+		Uid:      o.Uid.DeepCopy(),
+		Username: o.Username,
+		DeviceID: o.DeviceID.DeepCopy(),
 	}
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/remote.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/remote.go
index bc4c3020..231af30e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/remote.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/remote.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/remote.avdl
 
 package chat1
@@ -232,8 +232,10 @@ func (o NewConversationRemoteRes) DeepCopy() NewConversationRemoteRes {
 }
 
 type GetMessagesRemoteRes struct {
-	Msgs      []MessageBoxed `codec:"msgs" json:"msgs"`
-	RateLimit *RateLimit     `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+	Msgs        []MessageBoxed          `codec:"msgs" json:"msgs"`
+	MembersType ConversationMembersType `codec:"membersType" json:"membersType"`
+	Visibility  keybase1.TLFVisibility  `codec:"visibility" json:"visibility"`
+	RateLimit   *RateLimit              `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
 }
 
 func (o GetMessagesRemoteRes) DeepCopy() GetMessagesRemoteRes {
@@ -249,6 +251,8 @@ func (o GetMessagesRemoteRes) DeepCopy() GetMessagesRemoteRes {
 			}
 			return ret
 		})(o.Msgs),
+		MembersType: o.MembersType.DeepCopy(),
+		Visibility:  o.Visibility.DeepCopy(),
 		RateLimit: (func(x *RateLimit) *RateLimit {
 			if x == nil {
 				return nil
@@ -962,11 +966,24 @@ func (o RemoteBotCommandsAdvertisementTLFID) DeepCopy() RemoteBotCommandsAdverti
 	}
 }
 
+type RemoteBotCommandsAdvertisementConv struct {
+	ConvID          ConversationID `codec:"convID" json:"convID"`
+	AdvertiseConvID ConversationID `codec:"advertiseConvID" json:"advertiseConvID"`
+}
+
+func (o RemoteBotCommandsAdvertisementConv) DeepCopy() RemoteBotCommandsAdvertisementConv {
+	return RemoteBotCommandsAdvertisementConv{
+		ConvID:          o.ConvID.DeepCopy(),
+		AdvertiseConvID: o.AdvertiseConvID.DeepCopy(),
+	}
+}
+
 type RemoteBotCommandsAdvertisement struct {
 	Typ__          BotCommandsAdvertisementTyp           `codec:"typ" json:"typ"`
 	Public__       *RemoteBotCommandsAdvertisementPublic `codec:"public,omitempty" json:"public,omitempty"`
 	TlfidMembers__ *RemoteBotCommandsAdvertisementTLFID  `codec:"tlfidMembers,omitempty" json:"tlfidMembers,omitempty"`
 	TlfidConvs__   *RemoteBotCommandsAdvertisementTLFID  `codec:"tlfidConvs,omitempty" json:"tlfidConvs,omitempty"`
+	Conv__         *RemoteBotCommandsAdvertisementConv   `codec:"conv,omitempty" json:"conv,omitempty"`
 }
 
 func (o *RemoteBotCommandsAdvertisement) Typ() (ret BotCommandsAdvertisementTyp, err error) {
@@ -986,6 +1003,11 @@ func (o *RemoteBotCommandsAdvertisement) Typ() (ret BotCommandsAdvertisementTyp,
 			err = errors.New("unexpected nil value for TlfidConvs__")
 			return ret, err
 		}
+	case BotCommandsAdvertisementTyp_CONV:
+		if o.Conv__ == nil {
+			err = errors.New("unexpected nil value for Conv__")
+			return ret, err
+		}
 	}
 	return o.Typ__, nil
 }
@@ -1020,6 +1042,16 @@ func (o RemoteBotCommandsAdvertisement) TlfidConvs() (res RemoteBotCommandsAdver
 	return *o.TlfidConvs__
 }
 
+func (o RemoteBotCommandsAdvertisement) Conv() (res RemoteBotCommandsAdvertisementConv) {
+	if o.Typ__ != BotCommandsAdvertisementTyp_CONV {
+		panic("wrong case accessed")
+	}
+	if o.Conv__ == nil {
+		return
+	}
+	return *o.Conv__
+}
+
 func NewRemoteBotCommandsAdvertisementWithPublic(v RemoteBotCommandsAdvertisementPublic) RemoteBotCommandsAdvertisement {
 	return RemoteBotCommandsAdvertisement{
 		Typ__:    BotCommandsAdvertisementTyp_PUBLIC,
@@ -1041,6 +1073,13 @@ func NewRemoteBotCommandsAdvertisementWithTlfidConvs(v RemoteBotCommandsAdvertis
 	}
 }
 
+func NewRemoteBotCommandsAdvertisementWithConv(v RemoteBotCommandsAdvertisementConv) RemoteBotCommandsAdvertisement {
+	return RemoteBotCommandsAdvertisement{
+		Typ__:  BotCommandsAdvertisementTyp_CONV,
+		Conv__: &v,
+	}
+}
+
 func (o RemoteBotCommandsAdvertisement) DeepCopy() RemoteBotCommandsAdvertisement {
 	return RemoteBotCommandsAdvertisement{
 		Typ__: o.Typ__.DeepCopy(),
@@ -1065,6 +1104,13 @@ func (o RemoteBotCommandsAdvertisement) DeepCopy() RemoteBotCommandsAdvertisemen
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.TlfidConvs__),
+		Conv__: (func(x *RemoteBotCommandsAdvertisementConv) *RemoteBotCommandsAdvertisementConv {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Conv__),
 	}
 }
 
@@ -1126,6 +1172,169 @@ func (o AdvertiseBotCommandsRes) DeepCopy() AdvertiseBotCommandsRes {
 	}
 }
 
+type RemoteClearBotCommandsFilterPublic struct {
+}
+
+func (o RemoteClearBotCommandsFilterPublic) DeepCopy() RemoteClearBotCommandsFilterPublic {
+	return RemoteClearBotCommandsFilterPublic{}
+}
+
+type RemoteClearBotCommandsFilterTLFID struct {
+	TlfID TLFID `codec:"tlfID" json:"tlfID"`
+}
+
+func (o RemoteClearBotCommandsFilterTLFID) DeepCopy() RemoteClearBotCommandsFilterTLFID {
+	return RemoteClearBotCommandsFilterTLFID{
+		TlfID: o.TlfID.DeepCopy(),
+	}
+}
+
+type RemoteClearBotCommandsFilterConv struct {
+	ConvID ConversationID `codec:"convID" json:"convID"`
+}
+
+func (o RemoteClearBotCommandsFilterConv) DeepCopy() RemoteClearBotCommandsFilterConv {
+	return RemoteClearBotCommandsFilterConv{
+		ConvID: o.ConvID.DeepCopy(),
+	}
+}
+
+type RemoteClearBotCommandsFilter struct {
+	Typ__          BotCommandsAdvertisementTyp         `codec:"typ" json:"typ"`
+	Public__       *RemoteClearBotCommandsFilterPublic `codec:"public,omitempty" json:"public,omitempty"`
+	TlfidMembers__ *RemoteClearBotCommandsFilterTLFID  `codec:"tlfidMembers,omitempty" json:"tlfidMembers,omitempty"`
+	TlfidConvs__   *RemoteClearBotCommandsFilterTLFID  `codec:"tlfidConvs,omitempty" json:"tlfidConvs,omitempty"`
+	Conv__         *RemoteClearBotCommandsFilterConv   `codec:"conv,omitempty" json:"conv,omitempty"`
+}
+
+func (o *RemoteClearBotCommandsFilter) Typ() (ret BotCommandsAdvertisementTyp, err error) {
+	switch o.Typ__ {
+	case BotCommandsAdvertisementTyp_PUBLIC:
+		if o.Public__ == nil {
+			err = errors.New("unexpected nil value for Public__")
+			return ret, err
+		}
+	case BotCommandsAdvertisementTyp_TLFID_MEMBERS:
+		if o.TlfidMembers__ == nil {
+			err = errors.New("unexpected nil value for TlfidMembers__")
+			return ret, err
+		}
+	case BotCommandsAdvertisementTyp_TLFID_CONVS:
+		if o.TlfidConvs__ == nil {
+			err = errors.New("unexpected nil value for TlfidConvs__")
+			return ret, err
+		}
+	case BotCommandsAdvertisementTyp_CONV:
+		if o.Conv__ == nil {
+			err = errors.New("unexpected nil value for Conv__")
+			return ret, err
+		}
+	}
+	return o.Typ__, nil
+}
+
+func (o RemoteClearBotCommandsFilter) Public() (res RemoteClearBotCommandsFilterPublic) {
+	if o.Typ__ != BotCommandsAdvertisementTyp_PUBLIC {
+		panic("wrong case accessed")
+	}
+	if o.Public__ == nil {
+		return
+	}
+	return *o.Public__
+}
+
+func (o RemoteClearBotCommandsFilter) TlfidMembers() (res RemoteClearBotCommandsFilterTLFID) {
+	if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_MEMBERS {
+		panic("wrong case accessed")
+	}
+	if o.TlfidMembers__ == nil {
+		return
+	}
+	return *o.TlfidMembers__
+}
+
+func (o RemoteClearBotCommandsFilter) TlfidConvs() (res RemoteClearBotCommandsFilterTLFID) {
+	if o.Typ__ != BotCommandsAdvertisementTyp_TLFID_CONVS {
+		panic("wrong case accessed")
+	}
+	if o.TlfidConvs__ == nil {
+		return
+	}
+	return *o.TlfidConvs__
+}
+
+func (o RemoteClearBotCommandsFilter) Conv() (res RemoteClearBotCommandsFilterConv) {
+	if o.Typ__ != BotCommandsAdvertisementTyp_CONV {
+		panic("wrong case accessed")
+	}
+	if o.Conv__ == nil {
+		return
+	}
+	return *o.Conv__
+}
+
+func NewRemoteClearBotCommandsFilterWithPublic(v RemoteClearBotCommandsFilterPublic) RemoteClearBotCommandsFilter {
+	return RemoteClearBotCommandsFilter{
+		Typ__:    BotCommandsAdvertisementTyp_PUBLIC,
+		Public__: &v,
+	}
+}
+
+func NewRemoteClearBotCommandsFilterWithTlfidMembers(v RemoteClearBotCommandsFilterTLFID) RemoteClearBotCommandsFilter {
+	return RemoteClearBotCommandsFilter{
+		Typ__:          BotCommandsAdvertisementTyp_TLFID_MEMBERS,
+		TlfidMembers__: &v,
+	}
+}
+
+func NewRemoteClearBotCommandsFilterWithTlfidConvs(v RemoteClearBotCommandsFilterTLFID) RemoteClearBotCommandsFilter {
+	return RemoteClearBotCommandsFilter{
+		Typ__:        BotCommandsAdvertisementTyp_TLFID_CONVS,
+		TlfidConvs__: &v,
+	}
+}
+
+func NewRemoteClearBotCommandsFilterWithConv(v RemoteClearBotCommandsFilterConv) RemoteClearBotCommandsFilter {
+	return RemoteClearBotCommandsFilter{
+		Typ__:  BotCommandsAdvertisementTyp_CONV,
+		Conv__: &v,
+	}
+}
+
+func (o RemoteClearBotCommandsFilter) DeepCopy() RemoteClearBotCommandsFilter {
+	return RemoteClearBotCommandsFilter{
+		Typ__: o.Typ__.DeepCopy(),
+		Public__: (func(x *RemoteClearBotCommandsFilterPublic) *RemoteClearBotCommandsFilterPublic {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Public__),
+		TlfidMembers__: (func(x *RemoteClearBotCommandsFilterTLFID) *RemoteClearBotCommandsFilterTLFID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.TlfidMembers__),
+		TlfidConvs__: (func(x *RemoteClearBotCommandsFilterTLFID) *RemoteClearBotCommandsFilterTLFID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.TlfidConvs__),
+		Conv__: (func(x *RemoteClearBotCommandsFilterConv) *RemoteClearBotCommandsFilterConv {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Conv__),
+	}
+}
+
 type ClearBotCommandsRes struct {
 	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
 }
@@ -1248,3 +1457,155 @@ func (o BotInfoHash) DeepCopy() BotInfoHash {
 		return append([]byte{}, x...)
 	})(o)
 }
+
+type GetDefaultTeamChannelsRes struct {
+	Convs     []ConversationID `codec:"convs" json:"convs"`
+	RateLimit *RateLimit       `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetDefaultTeamChannelsRes) DeepCopy() GetDefaultTeamChannelsRes {
+	return GetDefaultTeamChannelsRes{
+		Convs: (func(x []ConversationID) []ConversationID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ConversationID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Convs),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type SetDefaultTeamChannelsRes struct {
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o SetDefaultTeamChannelsRes) DeepCopy() SetDefaultTeamChannelsRes {
+	return SetDefaultTeamChannelsRes{
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type GetRecentJoinsRes struct {
+	NumJoins  int        `codec:"numJoins" json:"numJoins"`
+	RateLimit *RateLimit `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetRecentJoinsRes) DeepCopy() GetRecentJoinsRes {
+	return GetRecentJoinsRes{
+		NumJoins: o.NumJoins,
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type RefreshParticipantsRemoteRes struct {
+	HashMatch bool          `codec:"hashMatch" json:"hashMatch"`
+	Uids      []gregor1.UID `codec:"uids" json:"uids"`
+	Hash      string        `codec:"hash" json:"hash"`
+	RateLimit *RateLimit    `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o RefreshParticipantsRemoteRes) DeepCopy() RefreshParticipantsRemoteRes {
+	return RefreshParticipantsRemoteRes{
+		HashMatch: o.HashMatch,
+		Uids: (func(x []gregor1.UID) []gregor1.UID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]gregor1.UID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Uids),
+		Hash: o.Hash,
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type GetLastActiveAtRes struct {
+	LastActiveAt gregor1.Time `codec:"lastActiveAt" json:"lastActiveAt"`
+	RateLimit    *RateLimit   `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetLastActiveAtRes) DeepCopy() GetLastActiveAtRes {
+	return GetLastActiveAtRes{
+		LastActiveAt: o.LastActiveAt.DeepCopy(),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
+
+type ResetConversationMember struct {
+	ConvID ConversationID `codec:"convID" json:"convID"`
+	Uid    gregor1.UID    `codec:"uid" json:"uid"`
+}
+
+func (o ResetConversationMember) DeepCopy() ResetConversationMember {
+	return ResetConversationMember{
+		ConvID: o.ConvID.DeepCopy(),
+		Uid:    o.Uid.DeepCopy(),
+	}
+}
+
+type GetResetConversationsRes struct {
+	ResetConvs []ResetConversationMember `codec:"resetConvs" json:"resetConvs"`
+	RateLimit  *RateLimit                `codec:"rateLimit,omitempty" json:"rateLimit,omitempty"`
+}
+
+func (o GetResetConversationsRes) DeepCopy() GetResetConversationsRes {
+	return GetResetConversationsRes{
+		ResetConvs: (func(x []ResetConversationMember) []ResetConversationMember {
+			if x == nil {
+				return nil
+			}
+			ret := make([]ResetConversationMember, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.ResetConvs),
+		RateLimit: (func(x *RateLimit) *RateLimit {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.RateLimit),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/unfurl.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/unfurl.go
index 7b99d35d..6c3cc248 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/unfurl.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/chat1/unfurl.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/chat1/unfurl.avdl
 
 package chat1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth.go
index 3da25001..9d046db8 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/auth.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_internal.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_internal.go
index 3a0376cb..f6538cef 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_internal.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_internal.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/auth_internal.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_update.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_update.go
index 74fce37f..5a46086a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_update.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/auth_update.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/auth_update.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/common.go
index 27ba51d1..f842ea5b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/common.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/incoming.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/incoming.go
index 153cc160..c6b72805 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/incoming.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/incoming.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/incoming.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/outgoing.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/outgoing.go
index 685ece41..48b4415f 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/outgoing.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/outgoing.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/outgoing.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/remind.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/remind.go
index b949c545..48c904b1 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/remind.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/gregor1/remind.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/gregor1/remind.avdl
 
 package gregor1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/account.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/account.go
index f26f967d..ad02226e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/account.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/account.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/account.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/airdrop.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/airdrop.go
index ec00de3a..1208a83a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/airdrop.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/airdrop.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/airdrop.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/apiserver.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/apiserver.go
index 8e773533..dfae6490 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/apiserver.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/apiserver.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/apiserver.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/appstate.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/appstate.go
index 52478e31..5dcb87e0 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/appstate.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/appstate.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/appstate.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/audit.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/audit.go
index 1a4c7223..052408a7 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/audit.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/audit.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/audit.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/avatars.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/avatars.go
index 9e78e2f8..16834344 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/avatars.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/avatars.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/avatars.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/backend_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/backend_common.go
index ed83acf3..8de73b78 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/backend_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/backend_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/backend_common.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/badger.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/badger.go
index b2604354..c56bcda5 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/badger.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/badger.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/badger.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/block.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/block.go
index cb1b2c37..7e89bedc 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/block.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/block.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/block.avdl
 
 package keybase1
@@ -57,6 +57,38 @@ func (o GetBlockRes) DeepCopy() GetBlockRes {
 	}
 }
 
+type GetBlockSizesRes struct {
+	Sizes    []int         `codec:"sizes" json:"sizes"`
+	Statuses []BlockStatus `codec:"statuses" json:"statuses"`
+}
+
+func (o GetBlockSizesRes) DeepCopy() GetBlockSizesRes {
+	return GetBlockSizesRes{
+		Sizes: (func(x []int) []int {
+			if x == nil {
+				return nil
+			}
+			ret := make([]int, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Sizes),
+		Statuses: (func(x []BlockStatus) []BlockStatus {
+			if x == nil {
+				return nil
+			}
+			ret := make([]BlockStatus, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Statuses),
+	}
+}
+
 type BlockRefNonce [8]byte
 
 func (o BlockRefNonce) DeepCopy() BlockRefNonce {
@@ -151,3 +183,75 @@ type BlockPingResponse struct {
 func (o BlockPingResponse) DeepCopy() BlockPingResponse {
 	return BlockPingResponse{}
 }
+
+type UsageStatRecord struct {
+	Write      int64 `codec:"write" json:"write"`
+	Archive    int64 `codec:"archive" json:"archive"`
+	Read       int64 `codec:"read" json:"read"`
+	MdWrite    int64 `codec:"mdWrite" json:"mdWrite"`
+	GitWrite   int64 `codec:"gitWrite" json:"gitWrite"`
+	GitArchive int64 `codec:"gitArchive" json:"gitArchive"`
+}
+
+func (o UsageStatRecord) DeepCopy() UsageStatRecord {
+	return UsageStatRecord{
+		Write:      o.Write,
+		Archive:    o.Archive,
+		Read:       o.Read,
+		MdWrite:    o.MdWrite,
+		GitWrite:   o.GitWrite,
+		GitArchive: o.GitArchive,
+	}
+}
+
+type UsageStat struct {
+	Bytes  UsageStatRecord `codec:"bytes" json:"bytes"`
+	Blocks UsageStatRecord `codec:"blocks" json:"blocks"`
+	Mtime  Time            `codec:"mtime" json:"mtime"`
+}
+
+func (o UsageStat) DeepCopy() UsageStat {
+	return UsageStat{
+		Bytes:  o.Bytes.DeepCopy(),
+		Blocks: o.Blocks.DeepCopy(),
+		Mtime:  o.Mtime.DeepCopy(),
+	}
+}
+
+type FolderUsageStat struct {
+	FolderID string    `codec:"folderID" json:"folderID"`
+	Stats    UsageStat `codec:"stats" json:"stats"`
+}
+
+func (o FolderUsageStat) DeepCopy() FolderUsageStat {
+	return FolderUsageStat{
+		FolderID: o.FolderID,
+		Stats:    o.Stats.DeepCopy(),
+	}
+}
+
+type BlockQuotaInfo struct {
+	Folders  []FolderUsageStat `codec:"folders" json:"folders"`
+	Total    UsageStat         `codec:"total" json:"total"`
+	Limit    int64             `codec:"limit" json:"limit"`
+	GitLimit int64             `codec:"gitLimit" json:"gitLimit"`
+}
+
+func (o BlockQuotaInfo) DeepCopy() BlockQuotaInfo {
+	return BlockQuotaInfo{
+		Folders: (func(x []FolderUsageStat) []FolderUsageStat {
+			if x == nil {
+				return nil
+			}
+			ret := make([]FolderUsageStat, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Folders),
+		Total:    o.Total.DeepCopy(),
+		Limit:    o.Limit,
+		GitLimit: o.GitLimit,
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/bot.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/bot.go
index 8b9306f4..7520d839 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/bot.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/bot.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/bot.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/btc.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/btc.go
index f54533b8..1cd8ca41 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/btc.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/btc.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/btc.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/common.go
index 128329f7..4b4ae791 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/common.avdl
 
 package keybase1
@@ -26,6 +26,12 @@ func (o DurationSec) DeepCopy() DurationSec {
 	return o
 }
 
+type DurationMsec float64
+
+func (o DurationMsec) DeepCopy() DurationMsec {
+	return o
+}
+
 type StringKVPair struct {
 	Key   string `codec:"key" json:"key"`
 	Value string `codec:"value" json:"value"`
@@ -432,7 +438,7 @@ type PublicKey struct {
 	ParentID          string        `codec:"parentID" json:"parentID"`
 	DeviceID          DeviceID      `codec:"deviceID" json:"deviceID"`
 	DeviceDescription string        `codec:"deviceDescription" json:"deviceDescription"`
-	DeviceType        string        `codec:"deviceType" json:"deviceType"`
+	DeviceType        DeviceTypeV2  `codec:"deviceType" json:"deviceType"`
 	CTime             Time          `codec:"cTime" json:"cTime"`
 	ETime             Time          `codec:"eTime" json:"eTime"`
 	IsRevoked         bool          `codec:"isRevoked" json:"isRevoked"`
@@ -458,7 +464,7 @@ func (o PublicKey) DeepCopy() PublicKey {
 		ParentID:          o.ParentID,
 		DeviceID:          o.DeviceID.DeepCopy(),
 		DeviceDescription: o.DeviceDescription,
-		DeviceType:        o.DeviceType,
+		DeviceType:        o.DeviceType.DeepCopy(),
 		CTime:             o.CTime.DeepCopy(),
 		ETime:             o.ETime.DeepCopy(),
 		IsRevoked:         o.IsRevoked,
@@ -504,21 +510,21 @@ func (o User) DeepCopy() User {
 }
 
 type Device struct {
-	Type               string   `codec:"type" json:"type"`
-	Name               string   `codec:"name" json:"name"`
-	DeviceID           DeviceID `codec:"deviceID" json:"deviceID"`
-	DeviceNumberOfType int      `codec:"deviceNumberOfType" json:"deviceNumberOfType"`
-	CTime              Time     `codec:"cTime" json:"cTime"`
-	MTime              Time     `codec:"mTime" json:"mTime"`
-	LastUsedTime       Time     `codec:"lastUsedTime" json:"lastUsedTime"`
-	EncryptKey         KID      `codec:"encryptKey" json:"encryptKey"`
-	VerifyKey          KID      `codec:"verifyKey" json:"verifyKey"`
-	Status             int      `codec:"status" json:"status"`
+	Type               DeviceTypeV2 `codec:"type" json:"type"`
+	Name               string       `codec:"name" json:"name"`
+	DeviceID           DeviceID     `codec:"deviceID" json:"deviceID"`
+	DeviceNumberOfType int          `codec:"deviceNumberOfType" json:"deviceNumberOfType"`
+	CTime              Time         `codec:"cTime" json:"cTime"`
+	MTime              Time         `codec:"mTime" json:"mTime"`
+	LastUsedTime       Time         `codec:"lastUsedTime" json:"lastUsedTime"`
+	EncryptKey         KID          `codec:"encryptKey" json:"encryptKey"`
+	VerifyKey          KID          `codec:"verifyKey" json:"verifyKey"`
+	Status             int          `codec:"status" json:"status"`
 }
 
 func (o Device) DeepCopy() Device {
 	return Device{
-		Type:               o.Type,
+		Type:               o.Type.DeepCopy(),
 		Name:               o.Name,
 		DeviceID:           o.DeviceID.DeepCopy(),
 		DeviceNumberOfType: o.DeviceNumberOfType,
@@ -557,6 +563,12 @@ func (e DeviceType) String() string {
 	return fmt.Sprintf("%v", int(e))
 }
 
+type DeviceTypeV2 string
+
+func (o DeviceTypeV2) DeepCopy() DeviceTypeV2 {
+	return o
+}
+
 type Stream struct {
 	Fd int `codec:"fd" json:"fd"`
 }
@@ -1061,26 +1073,84 @@ func (e OfflineAvailability) String() string {
 	return fmt.Sprintf("%v", int(e))
 }
 
+type UserReacji struct {
+	Name             string  `codec:"name" json:"name"`
+	CustomAddr       *string `codec:"customAddr,omitempty" json:"customAddr,omitempty"`
+	CustomAddrNoAnim *string `codec:"customAddrNoAnim,omitempty" json:"customAddrNoAnim,omitempty"`
+}
+
+func (o UserReacji) DeepCopy() UserReacji {
+	return UserReacji{
+		Name: o.Name,
+		CustomAddr: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.CustomAddr),
+		CustomAddrNoAnim: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.CustomAddrNoAnim),
+	}
+}
+
 type ReacjiSkinTone int
 
-func (o ReacjiSkinTone) DeepCopy() ReacjiSkinTone {
-	return o
+const (
+	ReacjiSkinTone_NONE      ReacjiSkinTone = 0
+	ReacjiSkinTone_SKINTONE1 ReacjiSkinTone = 1
+	ReacjiSkinTone_SKINTONE2 ReacjiSkinTone = 2
+	ReacjiSkinTone_SKINTONE3 ReacjiSkinTone = 3
+	ReacjiSkinTone_SKINTONE4 ReacjiSkinTone = 4
+	ReacjiSkinTone_SKINTONE5 ReacjiSkinTone = 5
+)
+
+func (o ReacjiSkinTone) DeepCopy() ReacjiSkinTone { return o }
+
+var ReacjiSkinToneMap = map[string]ReacjiSkinTone{
+	"NONE":      0,
+	"SKINTONE1": 1,
+	"SKINTONE2": 2,
+	"SKINTONE3": 3,
+	"SKINTONE4": 4,
+	"SKINTONE5": 5,
+}
+
+var ReacjiSkinToneRevMap = map[ReacjiSkinTone]string{
+	0: "NONE",
+	1: "SKINTONE1",
+	2: "SKINTONE2",
+	3: "SKINTONE3",
+	4: "SKINTONE4",
+	5: "SKINTONE5",
+}
+
+func (e ReacjiSkinTone) String() string {
+	if v, ok := ReacjiSkinToneRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
 }
 
 type UserReacjis struct {
-	TopReacjis []string       `codec:"topReacjis" json:"topReacjis"`
+	TopReacjis []UserReacji   `codec:"topReacjis" json:"topReacjis"`
 	SkinTone   ReacjiSkinTone `codec:"skinTone" json:"skinTone"`
 }
 
 func (o UserReacjis) DeepCopy() UserReacjis {
 	return UserReacjis{
-		TopReacjis: (func(x []string) []string {
+		TopReacjis: (func(x []UserReacji) []UserReacji {
 			if x == nil {
 				return nil
 			}
-			ret := make([]string, len(x))
+			ret := make([]UserReacji, len(x))
 			for i, v := range x {
-				vCopy := v
+				vCopy := v.DeepCopy()
 				ret[i] = vCopy
 			}
 			return ret
@@ -1088,3 +1158,38 @@ func (o UserReacjis) DeepCopy() UserReacjis {
 		SkinTone: o.SkinTone.DeepCopy(),
 	}
 }
+
+type WotStatusType int
+
+const (
+	WotStatusType_NONE     WotStatusType = 0
+	WotStatusType_PROPOSED WotStatusType = 1
+	WotStatusType_ACCEPTED WotStatusType = 2
+	WotStatusType_REJECTED WotStatusType = 3
+	WotStatusType_REVOKED  WotStatusType = 4
+)
+
+func (o WotStatusType) DeepCopy() WotStatusType { return o }
+
+var WotStatusTypeMap = map[string]WotStatusType{
+	"NONE":     0,
+	"PROPOSED": 1,
+	"ACCEPTED": 2,
+	"REJECTED": 3,
+	"REVOKED":  4,
+}
+
+var WotStatusTypeRevMap = map[WotStatusType]string{
+	0: "NONE",
+	1: "PROPOSED",
+	2: "ACCEPTED",
+	3: "REJECTED",
+	4: "REVOKED",
+}
+
+func (e WotStatusType) String() string {
+	if v, ok := WotStatusTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/config.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/config.go
index 3700dcad..49debf40 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/config.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/config.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/config.avdl
 
 package keybase1
@@ -9,11 +9,12 @@ import (
 )
 
 type CurrentStatus struct {
-	Configured     bool  `codec:"configured" json:"configured"`
-	Registered     bool  `codec:"registered" json:"registered"`
-	LoggedIn       bool  `codec:"loggedIn" json:"loggedIn"`
-	SessionIsValid bool  `codec:"sessionIsValid" json:"sessionIsValid"`
-	User           *User `codec:"user,omitempty" json:"user,omitempty"`
+	Configured     bool   `codec:"configured" json:"configured"`
+	Registered     bool   `codec:"registered" json:"registered"`
+	LoggedIn       bool   `codec:"loggedIn" json:"loggedIn"`
+	SessionIsValid bool   `codec:"sessionIsValid" json:"sessionIsValid"`
+	User           *User  `codec:"user,omitempty" json:"user,omitempty"`
+	DeviceName     string `codec:"deviceName" json:"deviceName"`
 }
 
 func (o CurrentStatus) DeepCopy() CurrentStatus {
@@ -29,6 +30,7 @@ func (o CurrentStatus) DeepCopy() CurrentStatus {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.User),
+		DeviceName: o.DeviceName,
 	}
 }
 
@@ -331,6 +333,7 @@ type KbServiceStatus struct {
 	Pid     string `codec:"pid" json:"pid"`
 	Log     string `codec:"log" json:"log"`
 	EkLog   string `codec:"ekLog" json:"ekLog"`
+	PerfLog string `codec:"perfLog" json:"perfLog"`
 }
 
 func (o KbServiceStatus) DeepCopy() KbServiceStatus {
@@ -340,6 +343,7 @@ func (o KbServiceStatus) DeepCopy() KbServiceStatus {
 		Pid:     o.Pid,
 		Log:     o.Log,
 		EkLog:   o.EkLog,
+		PerfLog: o.PerfLog,
 	}
 }
 
@@ -349,6 +353,7 @@ type KBFSStatus struct {
 	Running          bool   `codec:"running" json:"running"`
 	Pid              string `codec:"pid" json:"pid"`
 	Log              string `codec:"log" json:"log"`
+	PerfLog          string `codec:"perfLog" json:"perfLog"`
 	Mount            string `codec:"mount" json:"mount"`
 }
 
@@ -359,6 +364,7 @@ func (o KBFSStatus) DeepCopy() KBFSStatus {
 		Running:          o.Running,
 		Pid:              o.Pid,
 		Log:              o.Log,
+		PerfLog:          o.PerfLog,
 		Mount:            o.Mount,
 	}
 }
@@ -398,12 +404,14 @@ func (o StartStatus) DeepCopy() StartStatus {
 }
 
 type GitStatus struct {
-	Log string `codec:"log" json:"log"`
+	Log     string `codec:"log" json:"log"`
+	PerfLog string `codec:"perfLog" json:"perfLog"`
 }
 
 func (o GitStatus) DeepCopy() GitStatus {
 	return GitStatus{
-		Log: o.Log,
+		Log:     o.Log,
+		PerfLog: o.PerfLog,
 	}
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/constants.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/constants.go
index c9d45956..75242f83 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/constants.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/constants.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/constants.avdl
 
 package keybase1
@@ -12,6 +12,7 @@ type StatusCode int
 const (
 	StatusCode_SCOk                                        StatusCode = 0
 	StatusCode_SCInputError                                StatusCode = 100
+	StatusCode_SCAssertionParseError                       StatusCode = 101
 	StatusCode_SCLoginRequired                             StatusCode = 201
 	StatusCode_SCBadSession                                StatusCode = 202
 	StatusCode_SCBadLoginUserNotFound                      StatusCode = 203
@@ -34,11 +35,13 @@ const (
 	StatusCode_SCWrongCryptoFormat                         StatusCode = 279
 	StatusCode_SCDecryptionError                           StatusCode = 280
 	StatusCode_SCInvalidAddress                            StatusCode = 281
+	StatusCode_SCWrongCryptoMsgType                        StatusCode = 282
 	StatusCode_SCNoSession                                 StatusCode = 283
 	StatusCode_SCAccountReset                              StatusCode = 290
 	StatusCode_SCIdentifiesFailed                          StatusCode = 295
 	StatusCode_SCNoSpaceOnDevice                           StatusCode = 297
 	StatusCode_SCMerkleClientError                         StatusCode = 299
+	StatusCode_SCMerkleUpdateRoot                          StatusCode = 300
 	StatusCode_SCBadEmail                                  StatusCode = 472
 	StatusCode_SCRateLimit                                 StatusCode = 602
 	StatusCode_SCBadSignupUsernameTaken                    StatusCode = 701
@@ -69,6 +72,7 @@ const (
 	StatusCode_SCKeyDuplicateUpdate                        StatusCode = 921
 	StatusCode_SCSibkeyAlreadyExists                       StatusCode = 922
 	StatusCode_SCDecryptionKeyNotFound                     StatusCode = 924
+	StatusCode_SCVerificationKeyNotFound                   StatusCode = 925
 	StatusCode_SCKeyNoPGPEncryption                        StatusCode = 927
 	StatusCode_SCKeyNoNaClEncryption                       StatusCode = 928
 	StatusCode_SCKeySyncedPGPNotFound                      StatusCode = 929
@@ -102,6 +106,7 @@ const (
 	StatusCode_SCGenericAPIError                           StatusCode = 1600
 	StatusCode_SCAPINetworkError                           StatusCode = 1601
 	StatusCode_SCTimeout                                   StatusCode = 1602
+	StatusCode_SCKBFSClientTimeout                         StatusCode = 1603
 	StatusCode_SCProofError                                StatusCode = 1701
 	StatusCode_SCIdentificationExpired                     StatusCode = 1702
 	StatusCode_SCSelfNotFound                              StatusCode = 1703
@@ -142,6 +147,8 @@ const (
 	StatusCode_SCChatNotInTeam                             StatusCode = 2517
 	StatusCode_SCChatStalePreviousState                    StatusCode = 2518
 	StatusCode_SCChatEphemeralRetentionPolicyViolatedError StatusCode = 2519
+	StatusCode_SCChatUsersAlreadyInConversationError       StatusCode = 2520
+	StatusCode_SCChatBadConversationError                  StatusCode = 2521
 	StatusCode_SCTeamBadMembership                         StatusCode = 2604
 	StatusCode_SCTeamSelfNotOwner                          StatusCode = 2607
 	StatusCode_SCTeamNotFound                              StatusCode = 2614
@@ -152,6 +159,8 @@ const (
 	StatusCode_SCNoOp                                      StatusCode = 2638
 	StatusCode_SCTeamInviteBadCancel                       StatusCode = 2645
 	StatusCode_SCTeamInviteBadToken                        StatusCode = 2646
+	StatusCode_SCTeamInviteCompletionMissing               StatusCode = 2648
+	StatusCode_SCTeamBadNameReservedDB                     StatusCode = 2650
 	StatusCode_SCTeamTarDuplicate                          StatusCode = 2663
 	StatusCode_SCTeamTarNotFound                           StatusCode = 2664
 	StatusCode_SCTeamMemberExists                          StatusCode = 2665
@@ -188,6 +197,7 @@ const (
 	StatusCode_SCTeamStorageBadGeneration                  StatusCode = 2761
 	StatusCode_SCTeamStorageNotFound                       StatusCode = 2762
 	StatusCode_SCTeamContactSettingsBlock                  StatusCode = 2763
+	StatusCode_SCTeamSeitanInviteNeedPUK                   StatusCode = 2770
 	StatusCode_SCEphemeralKeyBadGeneration                 StatusCode = 2900
 	StatusCode_SCEphemeralKeyUnexpectedBox                 StatusCode = 2901
 	StatusCode_SCEphemeralKeyMissingBox                    StatusCode = 2902
@@ -242,143 +252,154 @@ const (
 	StatusCode_SCTeambotKeyOldBoxedGeneration              StatusCode = 3801
 	StatusCode_SCTeambotKeyBadGeneration                   StatusCode = 3802
 	StatusCode_SCAirdropRegisterFailedMisc                 StatusCode = 4207
+	StatusCode_SCSimpleFSNameExists                        StatusCode = 5101
+	StatusCode_SCSimpleFSDirNotEmpty                       StatusCode = 5102
+	StatusCode_SCSimpleFSNotExist                          StatusCode = 5103
+	StatusCode_SCSimpleFSNoAccess                          StatusCode = 5104
 )
 
 func (o StatusCode) DeepCopy() StatusCode { return o }
 
 var StatusCodeMap = map[string]StatusCode{
-	"SCOk":                        0,
-	"SCInputError":                100,
-	"SCLoginRequired":             201,
-	"SCBadSession":                202,
-	"SCBadLoginUserNotFound":      203,
-	"SCBadLoginPassword":          204,
-	"SCNotFound":                  205,
-	"SCThrottleControl":           210,
-	"SCDeleted":                   216,
-	"SCGeneric":                   218,
-	"SCAlreadyLoggedIn":           235,
-	"SCExists":                    230,
-	"SCCanceled":                  237,
-	"SCInputCanceled":             239,
-	"SCBadUsername":               243,
-	"SCOffline":                   267,
-	"SCReloginRequired":           274,
-	"SCResolutionFailed":          275,
-	"SCProfileNotPublic":          276,
-	"SCIdentifyFailed":            277,
-	"SCTrackingBroke":             278,
-	"SCWrongCryptoFormat":         279,
-	"SCDecryptionError":           280,
-	"SCInvalidAddress":            281,
-	"SCNoSession":                 283,
-	"SCAccountReset":              290,
-	"SCIdentifiesFailed":          295,
-	"SCNoSpaceOnDevice":           297,
-	"SCMerkleClientError":         299,
-	"SCBadEmail":                  472,
-	"SCRateLimit":                 602,
-	"SCBadSignupUsernameTaken":    701,
-	"SCDuplicate":                 706,
-	"SCBadInvitationCode":         707,
-	"SCBadSignupUsernameReserved": 710,
-	"SCBadSignupTeamName":         711,
-	"SCFeatureFlag":               712,
-	"SCEmailTaken":                713,
-	"SCEmailAlreadyAdded":         714,
-	"SCEmailLimitExceeded":        715,
-	"SCEmailCannotDeletePrimary":  716,
-	"SCEmailUnknown":              717,
-	"SCBotSignupTokenNotFound":    719,
-	"SCNoUpdate":                  723,
-	"SCMissingResult":             801,
-	"SCKeyNotFound":               901,
-	"SCKeyCorrupted":              905,
-	"SCKeyInUse":                  907,
-	"SCKeyBadGen":                 913,
-	"SCKeyNoSecret":               914,
-	"SCKeyBadUIDs":                915,
-	"SCKeyNoActive":               916,
-	"SCKeyNoSig":                  917,
-	"SCKeyBadSig":                 918,
-	"SCKeyBadEldest":              919,
-	"SCKeyNoEldest":               920,
-	"SCKeyDuplicateUpdate":        921,
-	"SCSibkeyAlreadyExists":       922,
-	"SCDecryptionKeyNotFound":     924,
-	"SCKeyNoPGPEncryption":        927,
-	"SCKeyNoNaClEncryption":       928,
-	"SCKeySyncedPGPNotFound":      929,
-	"SCKeyNoMatchingGPG":          930,
-	"SCKeyRevoked":                931,
-	"SCSigCannotVerify":           1002,
-	"SCSigWrongKey":               1008,
-	"SCSigOldSeqno":               1010,
-	"SCSigCreationDisallowed":     1016,
-	"SCSigMissingRatchet":         1021,
-	"SCSigBadTotalOrder":          1022,
-	"SCBadTrackSession":           1301,
-	"SCDeviceBadName":             1404,
-	"SCDeviceBadStatus":           1405,
-	"SCDeviceNameInUse":           1408,
-	"SCDeviceNotFound":            1409,
-	"SCDeviceMismatch":            1410,
-	"SCDeviceRequired":            1411,
-	"SCDevicePrevProvisioned":     1413,
-	"SCDeviceNoProvision":         1414,
-	"SCDeviceProvisionViaDevice":  1415,
-	"SCRevokeCurrentDevice":       1416,
-	"SCRevokeLastDevice":          1417,
-	"SCDeviceProvisionOffline":    1418,
-	"SCRevokeLastDevicePGP":       1419,
-	"SCStreamExists":              1501,
-	"SCStreamNotFound":            1502,
-	"SCStreamWrongKind":           1503,
-	"SCStreamEOF":                 1504,
-	"SCStreamUnknown":             1505,
-	"SCGenericAPIError":           1600,
-	"SCAPINetworkError":           1601,
-	"SCTimeout":                   1602,
-	"SCProofError":                1701,
-	"SCIdentificationExpired":     1702,
-	"SCSelfNotFound":              1703,
-	"SCBadKexPhrase":              1704,
-	"SCNoUIDelegation":            1705,
-	"SCNoUI":                      1706,
-	"SCGPGUnavailable":            1707,
-	"SCInvalidVersionError":       1800,
-	"SCOldVersionError":           1801,
-	"SCInvalidLocationError":      1802,
-	"SCServiceStatusError":        1803,
-	"SCInstallError":              1804,
-	"SCLoadKextError":             1810,
-	"SCLoadKextPermError":         1811,
-	"SCGitInternal":               2300,
-	"SCGitRepoAlreadyExists":      2301,
-	"SCGitInvalidRepoName":        2302,
-	"SCGitCannotDelete":           2303,
-	"SCGitRepoDoesntExist":        2304,
-	"SCLoginStateTimeout":         2400,
-	"SCChatInternal":              2500,
-	"SCChatRateLimit":             2501,
-	"SCChatConvExists":            2502,
-	"SCChatUnknownTLFID":          2503,
-	"SCChatNotInConv":             2504,
-	"SCChatBadMsg":                2505,
-	"SCChatBroadcast":             2506,
-	"SCChatAlreadySuperseded":     2507,
-	"SCChatAlreadyDeleted":        2508,
-	"SCChatTLFFinalized":          2509,
-	"SCChatCollision":             2510,
-	"SCIdentifySummaryError":      2511,
-	"SCNeedSelfRekey":             2512,
-	"SCNeedOtherRekey":            2513,
-	"SCChatMessageCollision":      2514,
-	"SCChatDuplicateMessage":      2515,
-	"SCChatClientError":           2516,
-	"SCChatNotInTeam":             2517,
-	"SCChatStalePreviousState":    2518,
+	"SCOk":                                        0,
+	"SCInputError":                                100,
+	"SCAssertionParseError":                       101,
+	"SCLoginRequired":                             201,
+	"SCBadSession":                                202,
+	"SCBadLoginUserNotFound":                      203,
+	"SCBadLoginPassword":                          204,
+	"SCNotFound":                                  205,
+	"SCThrottleControl":                           210,
+	"SCDeleted":                                   216,
+	"SCGeneric":                                   218,
+	"SCAlreadyLoggedIn":                           235,
+	"SCExists":                                    230,
+	"SCCanceled":                                  237,
+	"SCInputCanceled":                             239,
+	"SCBadUsername":                               243,
+	"SCOffline":                                   267,
+	"SCReloginRequired":                           274,
+	"SCResolutionFailed":                          275,
+	"SCProfileNotPublic":                          276,
+	"SCIdentifyFailed":                            277,
+	"SCTrackingBroke":                             278,
+	"SCWrongCryptoFormat":                         279,
+	"SCDecryptionError":                           280,
+	"SCInvalidAddress":                            281,
+	"SCWrongCryptoMsgType":                        282,
+	"SCNoSession":                                 283,
+	"SCAccountReset":                              290,
+	"SCIdentifiesFailed":                          295,
+	"SCNoSpaceOnDevice":                           297,
+	"SCMerkleClientError":                         299,
+	"SCMerkleUpdateRoot":                          300,
+	"SCBadEmail":                                  472,
+	"SCRateLimit":                                 602,
+	"SCBadSignupUsernameTaken":                    701,
+	"SCDuplicate":                                 706,
+	"SCBadInvitationCode":                         707,
+	"SCBadSignupUsernameReserved":                 710,
+	"SCBadSignupTeamName":                         711,
+	"SCFeatureFlag":                               712,
+	"SCEmailTaken":                                713,
+	"SCEmailAlreadyAdded":                         714,
+	"SCEmailLimitExceeded":                        715,
+	"SCEmailCannotDeletePrimary":                  716,
+	"SCEmailUnknown":                              717,
+	"SCBotSignupTokenNotFound":                    719,
+	"SCNoUpdate":                                  723,
+	"SCMissingResult":                             801,
+	"SCKeyNotFound":                               901,
+	"SCKeyCorrupted":                              905,
+	"SCKeyInUse":                                  907,
+	"SCKeyBadGen":                                 913,
+	"SCKeyNoSecret":                               914,
+	"SCKeyBadUIDs":                                915,
+	"SCKeyNoActive":                               916,
+	"SCKeyNoSig":                                  917,
+	"SCKeyBadSig":                                 918,
+	"SCKeyBadEldest":                              919,
+	"SCKeyNoEldest":                               920,
+	"SCKeyDuplicateUpdate":                        921,
+	"SCSibkeyAlreadyExists":                       922,
+	"SCDecryptionKeyNotFound":                     924,
+	"SCVerificationKeyNotFound":                   925,
+	"SCKeyNoPGPEncryption":                        927,
+	"SCKeyNoNaClEncryption":                       928,
+	"SCKeySyncedPGPNotFound":                      929,
+	"SCKeyNoMatchingGPG":                          930,
+	"SCKeyRevoked":                                931,
+	"SCSigCannotVerify":                           1002,
+	"SCSigWrongKey":                               1008,
+	"SCSigOldSeqno":                               1010,
+	"SCSigCreationDisallowed":                     1016,
+	"SCSigMissingRatchet":                         1021,
+	"SCSigBadTotalOrder":                          1022,
+	"SCBadTrackSession":                           1301,
+	"SCDeviceBadName":                             1404,
+	"SCDeviceBadStatus":                           1405,
+	"SCDeviceNameInUse":                           1408,
+	"SCDeviceNotFound":                            1409,
+	"SCDeviceMismatch":                            1410,
+	"SCDeviceRequired":                            1411,
+	"SCDevicePrevProvisioned":                     1413,
+	"SCDeviceNoProvision":                         1414,
+	"SCDeviceProvisionViaDevice":                  1415,
+	"SCRevokeCurrentDevice":                       1416,
+	"SCRevokeLastDevice":                          1417,
+	"SCDeviceProvisionOffline":                    1418,
+	"SCRevokeLastDevicePGP":                       1419,
+	"SCStreamExists":                              1501,
+	"SCStreamNotFound":                            1502,
+	"SCStreamWrongKind":                           1503,
+	"SCStreamEOF":                                 1504,
+	"SCStreamUnknown":                             1505,
+	"SCGenericAPIError":                           1600,
+	"SCAPINetworkError":                           1601,
+	"SCTimeout":                                   1602,
+	"SCKBFSClientTimeout":                         1603,
+	"SCProofError":                                1701,
+	"SCIdentificationExpired":                     1702,
+	"SCSelfNotFound":                              1703,
+	"SCBadKexPhrase":                              1704,
+	"SCNoUIDelegation":                            1705,
+	"SCNoUI":                                      1706,
+	"SCGPGUnavailable":                            1707,
+	"SCInvalidVersionError":                       1800,
+	"SCOldVersionError":                           1801,
+	"SCInvalidLocationError":                      1802,
+	"SCServiceStatusError":                        1803,
+	"SCInstallError":                              1804,
+	"SCLoadKextError":                             1810,
+	"SCLoadKextPermError":                         1811,
+	"SCGitInternal":                               2300,
+	"SCGitRepoAlreadyExists":                      2301,
+	"SCGitInvalidRepoName":                        2302,
+	"SCGitCannotDelete":                           2303,
+	"SCGitRepoDoesntExist":                        2304,
+	"SCLoginStateTimeout":                         2400,
+	"SCChatInternal":                              2500,
+	"SCChatRateLimit":                             2501,
+	"SCChatConvExists":                            2502,
+	"SCChatUnknownTLFID":                          2503,
+	"SCChatNotInConv":                             2504,
+	"SCChatBadMsg":                                2505,
+	"SCChatBroadcast":                             2506,
+	"SCChatAlreadySuperseded":                     2507,
+	"SCChatAlreadyDeleted":                        2508,
+	"SCChatTLFFinalized":                          2509,
+	"SCChatCollision":                             2510,
+	"SCIdentifySummaryError":                      2511,
+	"SCNeedSelfRekey":                             2512,
+	"SCNeedOtherRekey":                            2513,
+	"SCChatMessageCollision":                      2514,
+	"SCChatDuplicateMessage":                      2515,
+	"SCChatClientError":                           2516,
+	"SCChatNotInTeam":                             2517,
+	"SCChatStalePreviousState":                    2518,
 	"SCChatEphemeralRetentionPolicyViolatedError": 2519,
+	"SCChatUsersAlreadyInConversationError":       2520,
+	"SCChatBadConversationError":                  2521,
 	"SCTeamBadMembership":                         2604,
 	"SCTeamSelfNotOwner":                          2607,
 	"SCTeamNotFound":                              2614,
@@ -389,6 +410,8 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCNoOp":                                      2638,
 	"SCTeamInviteBadCancel":                       2645,
 	"SCTeamInviteBadToken":                        2646,
+	"SCTeamInviteCompletionMissing":               2648,
+	"SCTeamBadNameReservedDB":                     2650,
 	"SCTeamTarDuplicate":                          2663,
 	"SCTeamTarNotFound":                           2664,
 	"SCTeamMemberExists":                          2665,
@@ -425,6 +448,7 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCTeamStorageBadGeneration":                  2761,
 	"SCTeamStorageNotFound":                       2762,
 	"SCTeamContactSettingsBlock":                  2763,
+	"SCTeamSeitanInviteNeedPUK":                   2770,
 	"SCEphemeralKeyBadGeneration":                 2900,
 	"SCEphemeralKeyUnexpectedBox":                 2901,
 	"SCEphemeralKeyMissingBox":                    2902,
@@ -479,11 +503,16 @@ var StatusCodeMap = map[string]StatusCode{
 	"SCTeambotKeyOldBoxedGeneration":              3801,
 	"SCTeambotKeyBadGeneration":                   3802,
 	"SCAirdropRegisterFailedMisc":                 4207,
+	"SCSimpleFSNameExists":                        5101,
+	"SCSimpleFSDirNotEmpty":                       5102,
+	"SCSimpleFSNotExist":                          5103,
+	"SCSimpleFSNoAccess":                          5104,
 }
 
 var StatusCodeRevMap = map[StatusCode]string{
 	0:    "SCOk",
 	100:  "SCInputError",
+	101:  "SCAssertionParseError",
 	201:  "SCLoginRequired",
 	202:  "SCBadSession",
 	203:  "SCBadLoginUserNotFound",
@@ -506,11 +535,13 @@ var StatusCodeRevMap = map[StatusCode]string{
 	279:  "SCWrongCryptoFormat",
 	280:  "SCDecryptionError",
 	281:  "SCInvalidAddress",
+	282:  "SCWrongCryptoMsgType",
 	283:  "SCNoSession",
 	290:  "SCAccountReset",
 	295:  "SCIdentifiesFailed",
 	297:  "SCNoSpaceOnDevice",
 	299:  "SCMerkleClientError",
+	300:  "SCMerkleUpdateRoot",
 	472:  "SCBadEmail",
 	602:  "SCRateLimit",
 	701:  "SCBadSignupUsernameTaken",
@@ -541,6 +572,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	921:  "SCKeyDuplicateUpdate",
 	922:  "SCSibkeyAlreadyExists",
 	924:  "SCDecryptionKeyNotFound",
+	925:  "SCVerificationKeyNotFound",
 	927:  "SCKeyNoPGPEncryption",
 	928:  "SCKeyNoNaClEncryption",
 	929:  "SCKeySyncedPGPNotFound",
@@ -574,6 +606,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	1600: "SCGenericAPIError",
 	1601: "SCAPINetworkError",
 	1602: "SCTimeout",
+	1603: "SCKBFSClientTimeout",
 	1701: "SCProofError",
 	1702: "SCIdentificationExpired",
 	1703: "SCSelfNotFound",
@@ -614,6 +647,8 @@ var StatusCodeRevMap = map[StatusCode]string{
 	2517: "SCChatNotInTeam",
 	2518: "SCChatStalePreviousState",
 	2519: "SCChatEphemeralRetentionPolicyViolatedError",
+	2520: "SCChatUsersAlreadyInConversationError",
+	2521: "SCChatBadConversationError",
 	2604: "SCTeamBadMembership",
 	2607: "SCTeamSelfNotOwner",
 	2614: "SCTeamNotFound",
@@ -624,6 +659,8 @@ var StatusCodeRevMap = map[StatusCode]string{
 	2638: "SCNoOp",
 	2645: "SCTeamInviteBadCancel",
 	2646: "SCTeamInviteBadToken",
+	2648: "SCTeamInviteCompletionMissing",
+	2650: "SCTeamBadNameReservedDB",
 	2663: "SCTeamTarDuplicate",
 	2664: "SCTeamTarNotFound",
 	2665: "SCTeamMemberExists",
@@ -660,6 +697,7 @@ var StatusCodeRevMap = map[StatusCode]string{
 	2761: "SCTeamStorageBadGeneration",
 	2762: "SCTeamStorageNotFound",
 	2763: "SCTeamContactSettingsBlock",
+	2770: "SCTeamSeitanInviteNeedPUK",
 	2900: "SCEphemeralKeyBadGeneration",
 	2901: "SCEphemeralKeyUnexpectedBox",
 	2902: "SCEphemeralKeyMissingBox",
@@ -714,6 +752,10 @@ var StatusCodeRevMap = map[StatusCode]string{
 	3801: "SCTeambotKeyOldBoxedGeneration",
 	3802: "SCTeambotKeyBadGeneration",
 	4207: "SCAirdropRegisterFailedMisc",
+	5101: "SCSimpleFSNameExists",
+	5102: "SCSimpleFSDirNotEmpty",
+	5103: "SCSimpleFSNotExist",
+	5104: "SCSimpleFSNoAccess",
 }
 
 func (e StatusCode) String() string {
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/contacts.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/contacts.go
index 6853945c..995f81bf 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/contacts.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/contacts.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/contacts.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/crypto.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/crypto.go
index 3a492fa0..885a1b0e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/crypto.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/crypto.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/crypto.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/cryptocurrency.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/cryptocurrency.go
index 477357e7..d77d1dbd 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/cryptocurrency.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/cryptocurrency.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/cryptocurrency.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ctl.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ctl.go
index 1621930d..6a2c89e7 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ctl.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ctl.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/ctl.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/debugging.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/debugging.go
index 220cd124..15b0c95b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/debugging.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/debugging.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/debugging.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/delegate_ui_ctl.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/delegate_ui_ctl.go
index 527d6fbf..ae1b1476 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/delegate_ui_ctl.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/delegate_ui_ctl.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/delegate_ui_ctl.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/device.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/device.go
index ada7469f..fe4ab9a7 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/device.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/device.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/device.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/emails.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/emails.go
index 4fddd5de..54b776c3 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/emails.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/emails.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/emails.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ephemeral.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ephemeral.go
index def4172c..4080bfb2 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ephemeral.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ephemeral.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/ephemeral.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/favorite.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/favorite.go
index 6f74e8d9..e869ab5d 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/favorite.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/favorite.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/favorite.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/featured_bot.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/featured_bot.go
index d526f935..b0ba65ef 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/featured_bot.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/featured_bot.go
@@ -1,25 +1,27 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/featured_bot.avdl
 
 package keybase1
 
 type FeaturedBot struct {
-	BotAlias            string  `codec:"botAlias" json:"botAlias"`
-	Description         string  `codec:"description" json:"description"`
-	ExtendedDescription string  `codec:"extendedDescription" json:"extendedDescription"`
-	BotUsername         string  `codec:"botUsername" json:"botUsername"`
-	OwnerTeam           *string `codec:"ownerTeam,omitempty" json:"ownerTeam,omitempty"`
-	OwnerUser           *string `codec:"ownerUser,omitempty" json:"ownerUser,omitempty"`
-	Rank                int     `codec:"rank" json:"rank"`
-	IsPromoted          bool    `codec:"isPromoted" json:"isPromoted"`
+	BotAlias               string  `codec:"botAlias" json:"botAlias"`
+	Description            string  `codec:"description" json:"description"`
+	ExtendedDescription    string  `codec:"extendedDescription" json:"extendedDescription"`
+	ExtendedDescriptionRaw string  `codec:"extendedDescriptionRaw" json:"extendedDescriptionRaw"`
+	BotUsername            string  `codec:"botUsername" json:"botUsername"`
+	OwnerTeam              *string `codec:"ownerTeam,omitempty" json:"ownerTeam,omitempty"`
+	OwnerUser              *string `codec:"ownerUser,omitempty" json:"ownerUser,omitempty"`
+	Rank                   int     `codec:"rank" json:"rank"`
+	IsPromoted             bool    `codec:"isPromoted" json:"isPromoted"`
 }
 
 func (o FeaturedBot) DeepCopy() FeaturedBot {
 	return FeaturedBot{
-		BotAlias:            o.BotAlias,
-		Description:         o.Description,
-		ExtendedDescription: o.ExtendedDescription,
-		BotUsername:         o.BotUsername,
+		BotAlias:               o.BotAlias,
+		Description:            o.Description,
+		ExtendedDescription:    o.ExtendedDescription,
+		ExtendedDescriptionRaw: o.ExtendedDescriptionRaw,
+		BotUsername:            o.BotUsername,
 		OwnerTeam: (func(x *string) *string {
 			if x == nil {
 				return nil
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/fs.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/fs.go
index ee2bdc11..4e98fd66 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/fs.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/fs.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/fs.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/git.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/git.go
index f2283550..dc50a0f0 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/git.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/git.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/git.avdl
 
 package keybase1
@@ -223,8 +223,8 @@ type GitServerMetadata struct {
 
 func (o GitServerMetadata) DeepCopy() GitServerMetadata {
 	return GitServerMetadata{
-		Ctime:                   o.Ctime.DeepCopy(),
-		Mtime:                   o.Mtime.DeepCopy(),
+		Ctime: o.Ctime.DeepCopy(),
+		Mtime: o.Mtime.DeepCopy(),
 		LastModifyingUsername:   o.LastModifyingUsername,
 		LastModifyingDeviceID:   o.LastModifyingDeviceID.DeepCopy(),
 		LastModifyingDeviceName: o.LastModifyingDeviceName,
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_common.go
index d351b2b3..19cfbec7 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/gpg_common.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_ui.go
index ca7b6b54..30313260 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gpg_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/gpg_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor.go
index c1a15270..efc1bd8e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/gregor.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor_ui.go
index 5d9ce81e..b9824f86 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/gregor_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/gregor_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home.go
index ad9ddf89..a5e84955 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/home.avdl
 
 package keybase1
@@ -298,19 +298,19 @@ const (
 	HomeScreenTodoType_PROOF                   HomeScreenTodoType = 2
 	HomeScreenTodoType_DEVICE                  HomeScreenTodoType = 3
 	HomeScreenTodoType_FOLLOW                  HomeScreenTodoType = 4
-	HomeScreenTodoType_CHAT                    HomeScreenTodoType = 5
 	HomeScreenTodoType_PAPERKEY                HomeScreenTodoType = 6
 	HomeScreenTodoType_TEAM                    HomeScreenTodoType = 7
 	HomeScreenTodoType_FOLDER                  HomeScreenTodoType = 8
 	HomeScreenTodoType_GIT_REPO                HomeScreenTodoType = 9
 	HomeScreenTodoType_TEAM_SHOWCASE           HomeScreenTodoType = 10
-	HomeScreenTodoType_AVATAR_USER             HomeScreenTodoType = 11
 	HomeScreenTodoType_AVATAR_TEAM             HomeScreenTodoType = 12
 	HomeScreenTodoType_ADD_PHONE_NUMBER        HomeScreenTodoType = 18
 	HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER HomeScreenTodoType = 19
 	HomeScreenTodoType_VERIFY_ALL_EMAIL        HomeScreenTodoType = 20
 	HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY HomeScreenTodoType = 21
 	HomeScreenTodoType_ADD_EMAIL               HomeScreenTodoType = 22
+	HomeScreenTodoType_AVATAR_USER             HomeScreenTodoType = 23
+	HomeScreenTodoType_CHAT                    HomeScreenTodoType = 24
 	HomeScreenTodoType_ANNONCEMENT_PLACEHOLDER HomeScreenTodoType = 10000
 )
 
@@ -322,19 +322,19 @@ var HomeScreenTodoTypeMap = map[string]HomeScreenTodoType{
 	"PROOF":                   2,
 	"DEVICE":                  3,
 	"FOLLOW":                  4,
-	"CHAT":                    5,
 	"PAPERKEY":                6,
 	"TEAM":                    7,
 	"FOLDER":                  8,
 	"GIT_REPO":                9,
 	"TEAM_SHOWCASE":           10,
-	"AVATAR_USER":             11,
 	"AVATAR_TEAM":             12,
 	"ADD_PHONE_NUMBER":        18,
 	"VERIFY_ALL_PHONE_NUMBER": 19,
 	"VERIFY_ALL_EMAIL":        20,
 	"LEGACY_EMAIL_VISIBILITY": 21,
 	"ADD_EMAIL":               22,
+	"AVATAR_USER":             23,
+	"CHAT":                    24,
 	"ANNONCEMENT_PLACEHOLDER": 10000,
 }
 
@@ -344,19 +344,19 @@ var HomeScreenTodoTypeRevMap = map[HomeScreenTodoType]string{
 	2:     "PROOF",
 	3:     "DEVICE",
 	4:     "FOLLOW",
-	5:     "CHAT",
 	6:     "PAPERKEY",
 	7:     "TEAM",
 	8:     "FOLDER",
 	9:     "GIT_REPO",
 	10:    "TEAM_SHOWCASE",
-	11:    "AVATAR_USER",
 	12:    "AVATAR_TEAM",
 	18:    "ADD_PHONE_NUMBER",
 	19:    "VERIFY_ALL_PHONE_NUMBER",
 	20:    "VERIFY_ALL_EMAIL",
 	21:    "LEGACY_EMAIL_VISIBILITY",
 	22:    "ADD_EMAIL",
+	23:    "AVATAR_USER",
+	24:    "CHAT",
 	10000: "ANNONCEMENT_PLACEHOLDER",
 }
 
@@ -435,7 +435,7 @@ func (o HomeScreenTodo) LegacyEmailVisibility() (res EmailAddress) {
 
 func NewHomeScreenTodoWithVerifyAllPhoneNumber(v PhoneNumber) HomeScreenTodo {
 	return HomeScreenTodo{
-		T__:                    HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER,
+		T__: HomeScreenTodoType_VERIFY_ALL_PHONE_NUMBER,
 		VerifyAllPhoneNumber__: &v,
 	}
 }
@@ -449,7 +449,7 @@ func NewHomeScreenTodoWithVerifyAllEmail(v EmailAddress) HomeScreenTodo {
 
 func NewHomeScreenTodoWithLegacyEmailVisibility(v EmailAddress) HomeScreenTodo {
 	return HomeScreenTodo{
-		T__:                     HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY,
+		T__: HomeScreenTodoType_LEGACY_EMAIL_VISIBILITY,
 		LegacyEmailVisibility__: &v,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home_ui.go
index a7671a41..2039e02f 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/home_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/home_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify.go
index 3a810197..9ba6fe33 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/identify.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3.go
index af462f3c..02a4e62e 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/identify3.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_common.go
index 78b5377f..e6062ead 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/identify3_common.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_ui.go
index 1b3f34a2..a39ab91d 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify3_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/identify3_ui.avdl
 
 package keybase1
@@ -128,21 +128,23 @@ func (o Identify3RowMeta) DeepCopy() Identify3RowMeta {
 }
 
 type Identify3Row struct {
-	GuiID         Identify3GUIID     `codec:"guiID" json:"guiID"`
-	Key           string             `codec:"key" json:"key"`
-	Value         string             `codec:"value" json:"value"`
-	Priority      int                `codec:"priority" json:"priority"`
-	SiteURL       string             `codec:"siteURL" json:"siteURL"`
-	SiteIcon      []SizedImage       `codec:"siteIcon" json:"siteIcon"`
-	SiteIconFull  []SizedImage       `codec:"siteIconFull" json:"siteIconFull"`
-	SiteIconWhite []SizedImage       `codec:"siteIconWhite" json:"siteIconWhite"`
-	ProofURL      string             `codec:"proofURL" json:"proofURL"`
-	SigID         SigID              `codec:"sigID" json:"sigID"`
-	Ctime         Time               `codec:"ctime" json:"ctime"`
-	State         Identify3RowState  `codec:"state" json:"state"`
-	Metas         []Identify3RowMeta `codec:"metas" json:"metas"`
-	Color         Identify3RowColor  `codec:"color" json:"color"`
-	Kid           *KID               `codec:"kid,omitempty" json:"kid,omitempty"`
+	GuiID                Identify3GUIID     `codec:"guiID" json:"guiID"`
+	Key                  string             `codec:"key" json:"key"`
+	Value                string             `codec:"value" json:"value"`
+	Priority             int                `codec:"priority" json:"priority"`
+	SiteURL              string             `codec:"siteURL" json:"siteURL"`
+	SiteIcon             []SizedImage       `codec:"siteIcon" json:"siteIcon"`
+	SiteIconDarkmode     []SizedImage       `codec:"siteIconDarkmode" json:"siteIconDarkmode"`
+	SiteIconFull         []SizedImage       `codec:"siteIconFull" json:"siteIconFull"`
+	SiteIconFullDarkmode []SizedImage       `codec:"siteIconFullDarkmode" json:"siteIconFullDarkmode"`
+	ProofURL             string             `codec:"proofURL" json:"proofURL"`
+	SigID                SigID              `codec:"sigID" json:"sigID"`
+	Ctime                Time               `codec:"ctime" json:"ctime"`
+	State                Identify3RowState  `codec:"state" json:"state"`
+	Metas                []Identify3RowMeta `codec:"metas" json:"metas"`
+	Color                Identify3RowColor  `codec:"color" json:"color"`
+	Kid                  *KID               `codec:"kid,omitempty" json:"kid,omitempty"`
+	WotProof             *WotProof          `codec:"wotProof,omitempty" json:"wotProof,omitempty"`
 }
 
 func (o Identify3Row) DeepCopy() Identify3Row {
@@ -163,6 +165,17 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 			}
 			return ret
 		})(o.SiteIcon),
+		SiteIconDarkmode: (func(x []SizedImage) []SizedImage {
+			if x == nil {
+				return nil
+			}
+			ret := make([]SizedImage, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.SiteIconDarkmode),
 		SiteIconFull: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
@@ -174,7 +187,7 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 			}
 			return ret
 		})(o.SiteIconFull),
-		SiteIconWhite: (func(x []SizedImage) []SizedImage {
+		SiteIconFullDarkmode: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
 			}
@@ -184,7 +197,7 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 				ret[i] = vCopy
 			}
 			return ret
-		})(o.SiteIconWhite),
+		})(o.SiteIconFullDarkmode),
 		ProofURL: o.ProofURL,
 		SigID:    o.SigID.DeepCopy(),
 		Ctime:    o.Ctime.DeepCopy(),
@@ -208,5 +221,24 @@ func (o Identify3Row) DeepCopy() Identify3Row {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.Kid),
+		WotProof: (func(x *WotProof) *WotProof {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.WotProof),
+	}
+}
+
+type Identify3Summary struct {
+	GuiID            Identify3GUIID `codec:"guiID" json:"guiID"`
+	NumProofsToCheck int            `codec:"numProofsToCheck" json:"numProofsToCheck"`
+}
+
+func (o Identify3Summary) DeepCopy() Identify3Summary {
+	return Identify3Summary{
+		GuiID:            o.GuiID.DeepCopy(),
+		NumProofsToCheck: o.NumProofsToCheck,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_common.go
index bd1ff200..73822337 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/identify_common.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_ui.go
index e8118f9f..7ddb4f2b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/identify_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/identify_ui.avdl
 
 package keybase1
@@ -337,37 +337,33 @@ func (o UserTeamShowcase) DeepCopy() UserTeamShowcase {
 }
 
 type UserCard struct {
-	Following            int                `codec:"following" json:"following"`
-	Followers            int                `codec:"followers" json:"followers"`
-	Uid                  UID                `codec:"uid" json:"uid"`
-	FullName             string             `codec:"fullName" json:"fullName"`
-	Location             string             `codec:"location" json:"location"`
-	Bio                  string             `codec:"bio" json:"bio"`
-	BioDecorated         string             `codec:"bioDecorated" json:"bioDecorated"`
-	Website              string             `codec:"website" json:"website"`
-	Twitter              string             `codec:"twitter" json:"twitter"`
-	YouFollowThem        bool               `codec:"youFollowThem" json:"youFollowThem"`
-	TheyFollowYou        bool               `codec:"theyFollowYou" json:"theyFollowYou"`
-	TeamShowcase         []UserTeamShowcase `codec:"teamShowcase" json:"teamShowcase"`
-	RegisteredForAirdrop bool               `codec:"registeredForAirdrop" json:"registeredForAirdrop"`
-	StellarHidden        bool               `codec:"stellarHidden" json:"stellarHidden"`
-	Blocked              bool               `codec:"blocked" json:"blocked"`
-	HidFromFollowers     bool               `codec:"hidFromFollowers" json:"hidFromFollowers"`
+	UnverifiedNumFollowing int                `codec:"unverifiedNumFollowing" json:"unverifiedNumFollowing"`
+	UnverifiedNumFollowers int                `codec:"unverifiedNumFollowers" json:"unverifiedNumFollowers"`
+	Uid                    UID                `codec:"uid" json:"uid"`
+	FullName               string             `codec:"fullName" json:"fullName"`
+	Location               string             `codec:"location" json:"location"`
+	Bio                    string             `codec:"bio" json:"bio"`
+	BioDecorated           string             `codec:"bioDecorated" json:"bioDecorated"`
+	Website                string             `codec:"website" json:"website"`
+	Twitter                string             `codec:"twitter" json:"twitter"`
+	TeamShowcase           []UserTeamShowcase `codec:"teamShowcase" json:"teamShowcase"`
+	RegisteredForAirdrop   bool               `codec:"registeredForAirdrop" json:"registeredForAirdrop"`
+	StellarHidden          bool               `codec:"stellarHidden" json:"stellarHidden"`
+	Blocked                bool               `codec:"blocked" json:"blocked"`
+	HidFromFollowers       bool               `codec:"hidFromFollowers" json:"hidFromFollowers"`
 }
 
 func (o UserCard) DeepCopy() UserCard {
 	return UserCard{
-		Following:     o.Following,
-		Followers:     o.Followers,
-		Uid:           o.Uid.DeepCopy(),
-		FullName:      o.FullName,
-		Location:      o.Location,
-		Bio:           o.Bio,
-		BioDecorated:  o.BioDecorated,
-		Website:       o.Website,
-		Twitter:       o.Twitter,
-		YouFollowThem: o.YouFollowThem,
-		TheyFollowYou: o.TheyFollowYou,
+		UnverifiedNumFollowing: o.UnverifiedNumFollowing,
+		UnverifiedNumFollowers: o.UnverifiedNumFollowers,
+		Uid:          o.Uid.DeepCopy(),
+		FullName:     o.FullName,
+		Location:     o.Location,
+		Bio:          o.Bio,
+		BioDecorated: o.BioDecorated,
+		Website:      o.Website,
+		Twitter:      o.Twitter,
 		TeamShowcase: (func(x []UserTeamShowcase) []UserTeamShowcase {
 			if x == nil {
 				return nil
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/implicit_team_migration.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/implicit_team_migration.go
index 703ac01d..d2d8ac04 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/implicit_team_migration.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/implicit_team_migration.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/implicit_team_migration.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/incoming-share.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/incoming-share.go
new file mode 100644
index 00000000..3e60c1f8
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/incoming-share.go
@@ -0,0 +1,98 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/keybase1/incoming-share.avdl
+
+package keybase1
+
+import (
+	"fmt"
+)
+
+type IncomingShareType int
+
+const (
+	IncomingShareType_FILE  IncomingShareType = 0
+	IncomingShareType_TEXT  IncomingShareType = 1
+	IncomingShareType_IMAGE IncomingShareType = 2
+	IncomingShareType_VIDEO IncomingShareType = 3
+)
+
+func (o IncomingShareType) DeepCopy() IncomingShareType { return o }
+
+var IncomingShareTypeMap = map[string]IncomingShareType{
+	"FILE":  0,
+	"TEXT":  1,
+	"IMAGE": 2,
+	"VIDEO": 3,
+}
+
+var IncomingShareTypeRevMap = map[IncomingShareType]string{
+	0: "FILE",
+	1: "TEXT",
+	2: "IMAGE",
+	3: "VIDEO",
+}
+
+func (e IncomingShareType) String() string {
+	if v, ok := IncomingShareTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type IncomingShareItem struct {
+	Type          IncomingShareType `codec:"type" json:"type"`
+	OriginalPath  *string           `codec:"originalPath,omitempty" json:"originalPath,omitempty"`
+	OriginalSize  *int              `codec:"originalSize,omitempty" json:"originalSize,omitempty"`
+	ScaledPath    *string           `codec:"scaledPath,omitempty" json:"scaledPath,omitempty"`
+	ScaledSize    *int              `codec:"scaledSize,omitempty" json:"scaledSize,omitempty"`
+	ThumbnailPath *string           `codec:"thumbnailPath,omitempty" json:"thumbnailPath,omitempty"`
+	Content       *string           `codec:"content,omitempty" json:"content,omitempty"`
+}
+
+func (o IncomingShareItem) DeepCopy() IncomingShareItem {
+	return IncomingShareItem{
+		Type: o.Type.DeepCopy(),
+		OriginalPath: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OriginalPath),
+		OriginalSize: (func(x *int) *int {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OriginalSize),
+		ScaledPath: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ScaledPath),
+		ScaledSize: (func(x *int) *int {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ScaledSize),
+		ThumbnailPath: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ThumbnailPath),
+		Content: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Content),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/install.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/install.go
index 2b31fd3e..dee3b51b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/install.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/install.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/install.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/invite_friends.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/invite_friends.go
new file mode 100644
index 00000000..91daf4f3
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/invite_friends.go
@@ -0,0 +1,56 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/keybase1/invite_friends.avdl
+
+package keybase1
+
+type InviteCounts struct {
+	InviteCount      int     `codec:"inviteCount" json:"inviteCount"`
+	PercentageChange float64 `codec:"percentageChange" json:"percentageChange"`
+	ShowNumInvites   bool    `codec:"showNumInvites" json:"showNumInvites"`
+	ShowFire         bool    `codec:"showFire" json:"showFire"`
+	TooltipMarkdown  string  `codec:"tooltipMarkdown" json:"tooltipMarkdown"`
+}
+
+func (o InviteCounts) DeepCopy() InviteCounts {
+	return InviteCounts{
+		InviteCount:      o.InviteCount,
+		PercentageChange: o.PercentageChange,
+		ShowNumInvites:   o.ShowNumInvites,
+		ShowFire:         o.ShowFire,
+		TooltipMarkdown:  o.TooltipMarkdown,
+	}
+}
+
+type EmailInvites struct {
+	CommaSeparatedEmailsFromUser *string         `codec:"commaSeparatedEmailsFromUser,omitempty" json:"commaSeparatedEmailsFromUser,omitempty"`
+	EmailsFromContacts           *[]EmailAddress `codec:"emailsFromContacts,omitempty" json:"emailsFromContacts,omitempty"`
+}
+
+func (o EmailInvites) DeepCopy() EmailInvites {
+	return EmailInvites{
+		CommaSeparatedEmailsFromUser: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.CommaSeparatedEmailsFromUser),
+		EmailsFromContacts: (func(x *[]EmailAddress) *[]EmailAddress {
+			if x == nil {
+				return nil
+			}
+			tmp := (func(x []EmailAddress) []EmailAddress {
+				if x == nil {
+					return nil
+				}
+				ret := make([]EmailAddress, len(x))
+				for i, v := range x {
+					vCopy := v.DeepCopy()
+					ret[i] = vCopy
+				}
+				return ret
+			})((*x))
+			return &tmp
+		})(o.EmailsFromContacts),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs.go
index b32228aa..1826ca04 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kbfs.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_common.go
index 682044fa..cfd05c43 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kbfs_common.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_git.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_git.go
index a9e81d83..a24b13a6 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_git.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfs_git.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kbfs_git.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfsmount.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfsmount.go
index d9d727f1..05604a49 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfsmount.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kbfsmount.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kbfsmount.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee.go
index 1dc8010c..c2d4ff21 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kex2provisionee.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee2.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee2.go
index 148c8fad..02692579 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee2.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisionee2.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kex2provisionee2.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisioner.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisioner.go
index e24d4e88..a29589c4 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisioner.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kex2provisioner.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kex2provisioner.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kvstore.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kvstore.go
index cbb8d945..c2d04b54 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kvstore.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/kvstore.go
@@ -1,23 +1,29 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/kvstore.avdl
 
 package keybase1
 
 type KVGetResult struct {
-	TeamName   string `codec:"teamName" json:"teamName"`
-	Namespace  string `codec:"namespace" json:"namespace"`
-	EntryKey   string `codec:"entryKey" json:"entryKey"`
-	EntryValue string `codec:"entryValue" json:"entryValue"`
-	Revision   int    `codec:"revision" json:"revision"`
+	TeamName   string  `codec:"teamName" json:"teamName"`
+	Namespace  string  `codec:"namespace" json:"namespace"`
+	EntryKey   string  `codec:"entryKey" json:"entryKey"`
+	EntryValue *string `codec:"entryValue" json:"entryValue"`
+	Revision   int     `codec:"revision" json:"revision"`
 }
 
 func (o KVGetResult) DeepCopy() KVGetResult {
 	return KVGetResult{
-		TeamName:   o.TeamName,
-		Namespace:  o.Namespace,
-		EntryKey:   o.EntryKey,
-		EntryValue: o.EntryValue,
-		Revision:   o.Revision,
+		TeamName:  o.TeamName,
+		Namespace: o.Namespace,
+		EntryKey:  o.EntryKey,
+		EntryValue: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.EntryValue),
+		Revision: o.Revision,
 	}
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log.go
index 2874c1ef..44f91aad 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/log.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log_ui.go
index 39bd218c..dff2d7b5 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/log_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/log_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login.go
index 86e383e8..fdbf13dc 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/login.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login_ui.go
index 124ff2b3..abfd087b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/login_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/login_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/logsend.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/logsend.go
index 55df5fb9..36694758 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/logsend.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/logsend.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/logsend.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle.go
index f8c4320a..33d20f25 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/merkle.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle_store.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle_store.go
index a8ea0091..87f71e4c 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle_store.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/merkle_store.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/merkle_store.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata.go
index 1dc761f0..3505b2da 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/metadata.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata_update.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata_update.go
index 85d49c81..2e1e3309 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata_update.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/metadata_update.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/metadata_update.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/network_stats.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/network_stats.go
new file mode 100644
index 00000000..d5927026
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/network_stats.go
@@ -0,0 +1,66 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/keybase1/network_stats.avdl
+
+package keybase1
+
+import (
+	"fmt"
+)
+
+type NetworkSource int
+
+const (
+	NetworkSource_LOCAL  NetworkSource = 0
+	NetworkSource_REMOTE NetworkSource = 1
+)
+
+func (o NetworkSource) DeepCopy() NetworkSource { return o }
+
+var NetworkSourceMap = map[string]NetworkSource{
+	"LOCAL":  0,
+	"REMOTE": 1,
+}
+
+var NetworkSourceRevMap = map[NetworkSource]string{
+	0: "LOCAL",
+	1: "REMOTE",
+}
+
+func (e NetworkSource) String() string {
+	if v, ok := NetworkSourceRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type InstrumentationStat struct {
+	Tag       string       `codec:"t" json:"tag"`
+	NumCalls  int          `codec:"n" json:"numCalls"`
+	Ctime     Time         `codec:"c" json:"ctime"`
+	Mtime     Time         `codec:"m" json:"mtime"`
+	AvgDur    DurationMsec `codec:"ad" json:"avgDur"`
+	MaxDur    DurationMsec `codec:"xd" json:"maxDur"`
+	MinDur    DurationMsec `codec:"nd" json:"minDur"`
+	TotalDur  DurationMsec `codec:"td" json:"totalDur"`
+	AvgSize   int64        `codec:"as" json:"avgSize"`
+	MaxSize   int64        `codec:"xs" json:"maxSize"`
+	MinSize   int64        `codec:"ns" json:"minSize"`
+	TotalSize int64        `codec:"ts" json:"totalSize"`
+}
+
+func (o InstrumentationStat) DeepCopy() InstrumentationStat {
+	return InstrumentationStat{
+		Tag:       o.Tag,
+		NumCalls:  o.NumCalls,
+		Ctime:     o.Ctime.DeepCopy(),
+		Mtime:     o.Mtime.DeepCopy(),
+		AvgDur:    o.AvgDur.DeepCopy(),
+		MaxDur:    o.MaxDur.DeepCopy(),
+		MinDur:    o.MinDur.DeepCopy(),
+		TotalDur:  o.TotalDur.DeepCopy(),
+		AvgSize:   o.AvgSize,
+		MaxSize:   o.MaxSize,
+		MinSize:   o.MinSize,
+		TotalSize: o.TotalSize,
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_app.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_app.go
index 64f76c79..10f23060 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_app.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_app.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_app.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_audit.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_audit.go
index 8a39a98e..73f81f34 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_audit.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_audit.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_audit.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_badges.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_badges.go
index b3541b99..ef8ddfb1 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_badges.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_badges.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_badges.avdl
 
 package keybase1
@@ -74,6 +74,20 @@ func (o ResetState) DeepCopy() ResetState {
 	}
 }
 
+type WotUpdate struct {
+	Voucher string        `codec:"voucher" json:"voucher"`
+	Vouchee string        `codec:"vouchee" json:"vouchee"`
+	Status  WotStatusType `codec:"status" json:"status"`
+}
+
+func (o WotUpdate) DeepCopy() WotUpdate {
+	return WotUpdate{
+		Voucher: o.Voucher,
+		Vouchee: o.Vouchee,
+		Status:  o.Status.DeepCopy(),
+	}
+}
+
 type BadgeState struct {
 	NewTlfs                   int                     `codec:"newTlfs" json:"newTlfs"`
 	RekeysNeeded              int                     `codec:"rekeysNeeded" json:"rekeysNeeded"`
@@ -82,27 +96,33 @@ type BadgeState struct {
 	HomeTodoItems             int                     `codec:"homeTodoItems" json:"homeTodoItems"`
 	UnverifiedEmails          int                     `codec:"unverifiedEmails" json:"unverifiedEmails"`
 	UnverifiedPhones          int                     `codec:"unverifiedPhones" json:"unverifiedPhones"`
+	SmallTeamBadgeCount       int                     `codec:"smallTeamBadgeCount" json:"smallTeamBadgeCount"`
+	BigTeamBadgeCount         int                     `codec:"bigTeamBadgeCount" json:"bigTeamBadgeCount"`
+	NewTeamAccessRequestCount int                     `codec:"newTeamAccessRequestCount" json:"newTeamAccessRequestCount"`
 	NewDevices                []DeviceID              `codec:"newDevices" json:"newDevices"`
 	RevokedDevices            []DeviceID              `codec:"revokedDevices" json:"revokedDevices"`
 	Conversations             []BadgeConversationInfo `codec:"conversations" json:"conversations"`
 	NewGitRepoGlobalUniqueIDs []string                `codec:"newGitRepoGlobalUniqueIDs" json:"newGitRepoGlobalUniqueIDs"`
 	NewTeams                  []TeamID                `codec:"newTeams" json:"newTeams"`
 	DeletedTeams              []DeletedTeamInfo       `codec:"deletedTeams" json:"deletedTeams"`
-	NewTeamAccessRequests     []TeamID                `codec:"newTeamAccessRequests" json:"newTeamAccessRequests"`
 	TeamsWithResetUsers       []TeamMemberOutReset    `codec:"teamsWithResetUsers" json:"teamsWithResetUsers"`
 	UnreadWalletAccounts      []WalletAccountInfo     `codec:"unreadWalletAccounts" json:"unreadWalletAccounts"`
+	WotUpdates                map[string]WotUpdate    `codec:"wotUpdates" json:"wotUpdates"`
 	ResetState                ResetState              `codec:"resetState" json:"resetState"`
 }
 
 func (o BadgeState) DeepCopy() BadgeState {
 	return BadgeState{
-		NewTlfs:          o.NewTlfs,
-		RekeysNeeded:     o.RekeysNeeded,
-		NewFollowers:     o.NewFollowers,
-		InboxVers:        o.InboxVers,
-		HomeTodoItems:    o.HomeTodoItems,
-		UnverifiedEmails: o.UnverifiedEmails,
-		UnverifiedPhones: o.UnverifiedPhones,
+		NewTlfs:                   o.NewTlfs,
+		RekeysNeeded:              o.RekeysNeeded,
+		NewFollowers:              o.NewFollowers,
+		InboxVers:                 o.InboxVers,
+		HomeTodoItems:             o.HomeTodoItems,
+		UnverifiedEmails:          o.UnverifiedEmails,
+		UnverifiedPhones:          o.UnverifiedPhones,
+		SmallTeamBadgeCount:       o.SmallTeamBadgeCount,
+		BigTeamBadgeCount:         o.BigTeamBadgeCount,
+		NewTeamAccessRequestCount: o.NewTeamAccessRequestCount,
 		NewDevices: (func(x []DeviceID) []DeviceID {
 			if x == nil {
 				return nil
@@ -169,17 +189,6 @@ func (o BadgeState) DeepCopy() BadgeState {
 			}
 			return ret
 		})(o.DeletedTeams),
-		NewTeamAccessRequests: (func(x []TeamID) []TeamID {
-			if x == nil {
-				return nil
-			}
-			ret := make([]TeamID, len(x))
-			for i, v := range x {
-				vCopy := v.DeepCopy()
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.NewTeamAccessRequests),
 		TeamsWithResetUsers: (func(x []TeamMemberOutReset) []TeamMemberOutReset {
 			if x == nil {
 				return nil
@@ -202,31 +211,32 @@ func (o BadgeState) DeepCopy() BadgeState {
 			}
 			return ret
 		})(o.UnreadWalletAccounts),
+		WotUpdates: (func(x map[string]WotUpdate) map[string]WotUpdate {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[string]WotUpdate, len(x))
+			for k, v := range x {
+				kCopy := k
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.WotUpdates),
 		ResetState: o.ResetState.DeepCopy(),
 	}
 }
 
 type BadgeConversationInfo struct {
 	ConvID         ChatConversationID `codec:"convID" json:"convID"`
-	BadgeCounts    map[DeviceType]int `codec:"badgeCounts" json:"badgeCounts"`
+	BadgeCount     int                `codec:"badgeCount" json:"badgeCount"`
 	UnreadMessages int                `codec:"unreadMessages" json:"unreadMessages"`
 }
 
 func (o BadgeConversationInfo) DeepCopy() BadgeConversationInfo {
 	return BadgeConversationInfo{
-		ConvID: o.ConvID.DeepCopy(),
-		BadgeCounts: (func(x map[DeviceType]int) map[DeviceType]int {
-			if x == nil {
-				return nil
-			}
-			ret := make(map[DeviceType]int, len(x))
-			for k, v := range x {
-				kCopy := k.DeepCopy()
-				vCopy := v
-				ret[kCopy] = vCopy
-			}
-			return ret
-		})(o.BadgeCounts),
+		ConvID:         o.ConvID.DeepCopy(),
+		BadgeCount:     o.BadgeCount,
 		UnreadMessages: o.UnreadMessages,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_can_user_perform.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_can_user_perform.go
index 92be0aa3..84bca814 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_can_user_perform.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_can_user_perform.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_can_user_perform.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ctl.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ctl.go
index a937a7d6..93a2901f 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ctl.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ctl.go
@@ -1,70 +1,76 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_ctl.avdl
 
 package keybase1
 
 type NotificationChannels struct {
-	Session          bool `codec:"session" json:"session"`
-	Users            bool `codec:"users" json:"users"`
-	Kbfs             bool `codec:"kbfs" json:"kbfs"`
-	Kbfsdesktop      bool `codec:"kbfsdesktop" json:"kbfsdesktop"`
-	Kbfslegacy       bool `codec:"kbfslegacy" json:"kbfslegacy"`
-	Kbfssubscription bool `codec:"kbfssubscription" json:"kbfssubscription"`
-	Tracking         bool `codec:"tracking" json:"tracking"`
-	Favorites        bool `codec:"favorites" json:"favorites"`
-	Paperkeys        bool `codec:"paperkeys" json:"paperkeys"`
-	Keyfamily        bool `codec:"keyfamily" json:"keyfamily"`
-	Service          bool `codec:"service" json:"service"`
-	App              bool `codec:"app" json:"app"`
-	Chat             bool `codec:"chat" json:"chat"`
-	PGP              bool `codec:"pgp" json:"pgp"`
-	Kbfsrequest      bool `codec:"kbfsrequest" json:"kbfsrequest"`
-	Badges           bool `codec:"badges" json:"badges"`
-	Reachability     bool `codec:"reachability" json:"reachability"`
-	Team             bool `codec:"team" json:"team"`
-	Ephemeral        bool `codec:"ephemeral" json:"ephemeral"`
-	Teambot          bool `codec:"teambot" json:"teambot"`
-	Chatkbfsedits    bool `codec:"chatkbfsedits" json:"chatkbfsedits"`
-	Chatdev          bool `codec:"chatdev" json:"chatdev"`
-	Deviceclone      bool `codec:"deviceclone" json:"deviceclone"`
-	Chatattachments  bool `codec:"chatattachments" json:"chatattachments"`
-	Wallet           bool `codec:"wallet" json:"wallet"`
-	Audit            bool `codec:"audit" json:"audit"`
-	Runtimestats     bool `codec:"runtimestats" json:"runtimestats"`
-	FeaturedBots     bool `codec:"featuredBots" json:"featuredBots"`
-	Saltpack         bool `codec:"saltpack" json:"saltpack"`
+	Session              bool `codec:"session" json:"session"`
+	Users                bool `codec:"users" json:"users"`
+	Kbfs                 bool `codec:"kbfs" json:"kbfs"`
+	Kbfsdesktop          bool `codec:"kbfsdesktop" json:"kbfsdesktop"`
+	Kbfslegacy           bool `codec:"kbfslegacy" json:"kbfslegacy"`
+	Kbfssubscription     bool `codec:"kbfssubscription" json:"kbfssubscription"`
+	Tracking             bool `codec:"tracking" json:"tracking"`
+	Favorites            bool `codec:"favorites" json:"favorites"`
+	Paperkeys            bool `codec:"paperkeys" json:"paperkeys"`
+	Keyfamily            bool `codec:"keyfamily" json:"keyfamily"`
+	Service              bool `codec:"service" json:"service"`
+	App                  bool `codec:"app" json:"app"`
+	Chat                 bool `codec:"chat" json:"chat"`
+	PGP                  bool `codec:"pgp" json:"pgp"`
+	Kbfsrequest          bool `codec:"kbfsrequest" json:"kbfsrequest"`
+	Badges               bool `codec:"badges" json:"badges"`
+	Reachability         bool `codec:"reachability" json:"reachability"`
+	Team                 bool `codec:"team" json:"team"`
+	Ephemeral            bool `codec:"ephemeral" json:"ephemeral"`
+	Teambot              bool `codec:"teambot" json:"teambot"`
+	Chatkbfsedits        bool `codec:"chatkbfsedits" json:"chatkbfsedits"`
+	Chatdev              bool `codec:"chatdev" json:"chatdev"`
+	Chatemoji            bool `codec:"chatemoji" json:"chatemoji"`
+	Chatemojicross       bool `codec:"chatemojicross" json:"chatemojicross"`
+	Deviceclone          bool `codec:"deviceclone" json:"deviceclone"`
+	Chatattachments      bool `codec:"chatattachments" json:"chatattachments"`
+	Wallet               bool `codec:"wallet" json:"wallet"`
+	Audit                bool `codec:"audit" json:"audit"`
+	Runtimestats         bool `codec:"runtimestats" json:"runtimestats"`
+	FeaturedBots         bool `codec:"featuredBots" json:"featuredBots"`
+	Saltpack             bool `codec:"saltpack" json:"saltpack"`
+	AllowChatNotifySkips bool `codec:"allowChatNotifySkips" json:"allowChatNotifySkips"`
 }
 
 func (o NotificationChannels) DeepCopy() NotificationChannels {
 	return NotificationChannels{
-		Session:          o.Session,
-		Users:            o.Users,
-		Kbfs:             o.Kbfs,
-		Kbfsdesktop:      o.Kbfsdesktop,
-		Kbfslegacy:       o.Kbfslegacy,
-		Kbfssubscription: o.Kbfssubscription,
-		Tracking:         o.Tracking,
-		Favorites:        o.Favorites,
-		Paperkeys:        o.Paperkeys,
-		Keyfamily:        o.Keyfamily,
-		Service:          o.Service,
-		App:              o.App,
-		Chat:             o.Chat,
-		PGP:              o.PGP,
-		Kbfsrequest:      o.Kbfsrequest,
-		Badges:           o.Badges,
-		Reachability:     o.Reachability,
-		Team:             o.Team,
-		Ephemeral:        o.Ephemeral,
-		Teambot:          o.Teambot,
-		Chatkbfsedits:    o.Chatkbfsedits,
-		Chatdev:          o.Chatdev,
-		Deviceclone:      o.Deviceclone,
-		Chatattachments:  o.Chatattachments,
-		Wallet:           o.Wallet,
-		Audit:            o.Audit,
-		Runtimestats:     o.Runtimestats,
-		FeaturedBots:     o.FeaturedBots,
-		Saltpack:         o.Saltpack,
+		Session:              o.Session,
+		Users:                o.Users,
+		Kbfs:                 o.Kbfs,
+		Kbfsdesktop:          o.Kbfsdesktop,
+		Kbfslegacy:           o.Kbfslegacy,
+		Kbfssubscription:     o.Kbfssubscription,
+		Tracking:             o.Tracking,
+		Favorites:            o.Favorites,
+		Paperkeys:            o.Paperkeys,
+		Keyfamily:            o.Keyfamily,
+		Service:              o.Service,
+		App:                  o.App,
+		Chat:                 o.Chat,
+		PGP:                  o.PGP,
+		Kbfsrequest:          o.Kbfsrequest,
+		Badges:               o.Badges,
+		Reachability:         o.Reachability,
+		Team:                 o.Team,
+		Ephemeral:            o.Ephemeral,
+		Teambot:              o.Teambot,
+		Chatkbfsedits:        o.Chatkbfsedits,
+		Chatdev:              o.Chatdev,
+		Chatemoji:            o.Chatemoji,
+		Chatemojicross:       o.Chatemojicross,
+		Deviceclone:          o.Deviceclone,
+		Chatattachments:      o.Chatattachments,
+		Wallet:               o.Wallet,
+		Audit:                o.Audit,
+		Runtimestats:         o.Runtimestats,
+		FeaturedBots:         o.FeaturedBots,
+		Saltpack:             o.Saltpack,
+		AllowChatNotifySkips: o.AllowChatNotifySkips,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_device_clone.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_device_clone.go
index 61bfa51c..ad626031 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_device_clone.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_device_clone.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_device_clone.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_email.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_email.go
index 297afae3..377f114d 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_email.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_email.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_email.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ephemeral.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ephemeral.go
index f23a9fa0..fc3800f7 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ephemeral.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_ephemeral.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_ephemeral.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_favorites.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_favorites.go
index 5a30b97f..5b485a2a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_favorites.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_favorites.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_favorites.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_featuredbots.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_featuredbots.go
index ac43c6bf..017b841a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_featuredbots.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_featuredbots.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_featuredbots.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs.go
index aadffd81..5c5e10c3 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_fs.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs_request.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs_request.go
index a5d9259f..886c1a18 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs_request.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_fs_request.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_fs_request.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_invite_friends.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_invite_friends.go
new file mode 100644
index 00000000..60914212
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_invite_friends.go
@@ -0,0 +1,4 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/keybase1/notify_invite_friends.avdl
+
+package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_keyfamily.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_keyfamily.go
index 36fa67b3..b6784294 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_keyfamily.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_keyfamily.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_keyfamily.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_paperkey.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_paperkey.go
index 4ea5435c..038eb907 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_paperkey.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_paperkey.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_paperkey.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_pgp.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_pgp.go
index 7f8a6070..ad418b0a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_pgp.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_pgp.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_pgp.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_phone.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_phone.go
index 42c5e0f9..c42b49a3 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_phone.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_phone.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_phone.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_runtimestats.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_runtimestats.go
index 99906ffa..d01dd4cd 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_runtimestats.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_runtimestats.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_runtimestats.avdl
 
 package keybase1
@@ -104,9 +104,68 @@ func (o ProcessRuntimeStats) DeepCopy() ProcessRuntimeStats {
 	}
 }
 
+type PerfEventType int
+
+const (
+	PerfEventType_NETWORK      PerfEventType = 0
+	PerfEventType_TEAMBOXAUDIT PerfEventType = 1
+	PerfEventType_TEAMAUDIT    PerfEventType = 2
+	PerfEventType_USERCHAIN    PerfEventType = 3
+	PerfEventType_TEAMCHAIN    PerfEventType = 4
+	PerfEventType_CLEARCONV    PerfEventType = 5
+	PerfEventType_CLEARINBOX   PerfEventType = 6
+	PerfEventType_TEAMTREELOAD PerfEventType = 7
+)
+
+func (o PerfEventType) DeepCopy() PerfEventType { return o }
+
+var PerfEventTypeMap = map[string]PerfEventType{
+	"NETWORK":      0,
+	"TEAMBOXAUDIT": 1,
+	"TEAMAUDIT":    2,
+	"USERCHAIN":    3,
+	"TEAMCHAIN":    4,
+	"CLEARCONV":    5,
+	"CLEARINBOX":   6,
+	"TEAMTREELOAD": 7,
+}
+
+var PerfEventTypeRevMap = map[PerfEventType]string{
+	0: "NETWORK",
+	1: "TEAMBOXAUDIT",
+	2: "TEAMAUDIT",
+	3: "USERCHAIN",
+	4: "TEAMCHAIN",
+	5: "CLEARCONV",
+	6: "CLEARINBOX",
+	7: "TEAMTREELOAD",
+}
+
+func (e PerfEventType) String() string {
+	if v, ok := PerfEventTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type PerfEvent struct {
+	Message   string        `codec:"message" json:"message"`
+	Ctime     Time          `codec:"ctime" json:"ctime"`
+	EventType PerfEventType `codec:"eventType" json:"eventType"`
+}
+
+func (o PerfEvent) DeepCopy() PerfEvent {
+	return PerfEvent{
+		Message:   o.Message,
+		Ctime:     o.Ctime.DeepCopy(),
+		EventType: o.EventType.DeepCopy(),
+	}
+}
+
 type RuntimeStats struct {
 	ProcessStats        []ProcessRuntimeStats `codec:"processStats" json:"processStats"`
 	DbStats             []DbStats             `codec:"dbStats" json:"dbStats"`
+	PerfEvents          []PerfEvent           `codec:"perfEvents" json:"perfEvents"`
 	ConvLoaderActive    bool                  `codec:"convLoaderActive" json:"convLoaderActive"`
 	SelectiveSyncActive bool                  `codec:"selectiveSyncActive" json:"selectiveSyncActive"`
 }
@@ -135,6 +194,17 @@ func (o RuntimeStats) DeepCopy() RuntimeStats {
 			}
 			return ret
 		})(o.DbStats),
+		PerfEvents: (func(x []PerfEvent) []PerfEvent {
+			if x == nil {
+				return nil
+			}
+			ret := make([]PerfEvent, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.PerfEvents),
 		ConvLoaderActive:    o.ConvLoaderActive,
 		SelectiveSyncActive: o.SelectiveSyncActive,
 	}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_saltpack.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_saltpack.go
index 8df8a8d9..f1448660 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_saltpack.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_saltpack.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_saltpack.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_service.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_service.go
index e96d4ddf..478d7a52 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_service.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_service.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_service.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_session.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_session.go
index 3f89041e..c701d77c 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_session.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_session.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_session.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_team.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_team.go
index b90f13e4..59866f99 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_team.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_team.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_team.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_teambot.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_teambot.go
index 64d8242a..49bd516a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_teambot.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_teambot.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_teambot.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_tracking.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_tracking.go
index ecb4a58a..23917346 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_tracking.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_tracking.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_tracking.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_users.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_users.go
index 10aa26b9..5c16c324 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_users.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/notify_users.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/notify_users.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/os.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/os.go
index 1efd93ed..17d03699 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/os.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/os.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/os.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/paperprovision.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/paperprovision.go
index eafff4e0..b6d86091 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/paperprovision.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/paperprovision.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/paperprovision.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/passphrase_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/passphrase_common.go
index 1d31f46e..083de1c9 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/passphrase_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/passphrase_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/passphrase_common.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp.go
index c2869fa5..c8216451 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/pgp.avdl
 
 package keybase1
@@ -88,6 +88,7 @@ type PGPSigVerification struct {
 	Verified bool      `codec:"verified" json:"verified"`
 	Signer   User      `codec:"signer" json:"signer"`
 	SignKey  PublicKey `codec:"signKey" json:"signKey"`
+	Warnings []string  `codec:"warnings" json:"warnings"`
 }
 
 func (o PGPSigVerification) DeepCopy() PGPSigVerification {
@@ -96,6 +97,17 @@ func (o PGPSigVerification) DeepCopy() PGPSigVerification {
 		Verified: o.Verified,
 		Signer:   o.Signer.DeepCopy(),
 		SignKey:  o.SignKey.DeepCopy(),
+		Warnings: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Warnings),
 	}
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp_ui.go
index 1dd3ae74..8bf27832 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pgp_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/pgp_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/phone_numbers.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/phone_numbers.go
index 0ac2fe45..e2cd923b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/phone_numbers.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/phone_numbers.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/phone_numbers.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pprof.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pprof.go
index 3670f9ae..ffad20a3 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pprof.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/pprof.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/pprof.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/process.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/process.go
index 276acd63..0591ef95 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/process.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/process.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/process.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove.go
index 4d5d8f5e..27bafb65 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/prove.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_common.go
index b263e16e..91402e46 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/prove_common.avdl
 
 package keybase1
@@ -314,25 +314,10 @@ func (o ParamProofUsernameConfig) DeepCopy() ParamProofUsernameConfig {
 	}
 }
 
-type ParamProofLogoConfig struct {
-	SvgBlack string `codec:"svgBlack" json:"svg_black"`
-	SvgFull  string `codec:"svgFull" json:"svg_full"`
-	SvgWhite string `codec:"svgWhite" json:"svg_white"`
-}
-
-func (o ParamProofLogoConfig) DeepCopy() ParamProofLogoConfig {
-	return ParamProofLogoConfig{
-		SvgBlack: o.SvgBlack,
-		SvgFull:  o.SvgFull,
-		SvgWhite: o.SvgWhite,
-	}
-}
-
 type ParamProofServiceConfig struct {
 	Version        int                      `codec:"version" json:"version"`
 	Domain         string                   `codec:"domain" json:"domain"`
 	DisplayName    string                   `codec:"displayName" json:"display_name"`
-	Logo           *ParamProofLogoConfig    `codec:"logo,omitempty" json:"logo,omitempty"`
 	Description    string                   `codec:"description" json:"description"`
 	UsernameConfig ParamProofUsernameConfig `codec:"usernameConfig" json:"username"`
 	BrandColor     string                   `codec:"brandColor" json:"brand_color"`
@@ -345,16 +330,9 @@ type ParamProofServiceConfig struct {
 
 func (o ParamProofServiceConfig) DeepCopy() ParamProofServiceConfig {
 	return ParamProofServiceConfig{
-		Version:     o.Version,
-		Domain:      o.Domain,
-		DisplayName: o.DisplayName,
-		Logo: (func(x *ParamProofLogoConfig) *ParamProofLogoConfig {
-			if x == nil {
-				return nil
-			}
-			tmp := (*x).DeepCopy()
-			return &tmp
-		})(o.Logo),
+		Version:        o.Version,
+		Domain:         o.Domain,
+		DisplayName:    o.DisplayName,
 		Description:    o.Description,
 		UsernameConfig: o.UsernameConfig.DeepCopy(),
 		BrandColor:     o.BrandColor,
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_ui.go
index a9dc6a3b..be2fd8d9 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/prove_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/prove_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/provision_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/provision_ui.go
index af88e609..62b0e16b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/provision_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/provision_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/provision_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/quota.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/quota.go
index 4656fae8..f2f39022 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/quota.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/quota.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/quota.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reachability.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reachability.go
index 20a8d4f2..1d5ff06a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reachability.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reachability.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/reachability.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey.go
index d5e60c42..0f7ad939 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/rekey.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey_ui.go
index 83798426..5ea6fe8f 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/rekey_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/rekey_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reset.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reset.go
index c7d28b81..f8491395 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reset.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/reset.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/reset.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/revoke.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/revoke.go
index 0f7faab8..234b117c 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/revoke.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/revoke.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/revoke.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack.go
index 994648cd..bc916ecc 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/saltpack.avdl
 
 package keybase1
@@ -46,6 +46,7 @@ type SaltpackEncryptOptions struct {
 	NoSelfEncrypt             bool             `codec:"noSelfEncrypt" json:"noSelfEncrypt"`
 	Binary                    bool             `codec:"binary" json:"binary"`
 	SaltpackVersion           int              `codec:"saltpackVersion" json:"saltpackVersion"`
+	NoForcePoll               bool             `codec:"noForcePoll" json:"noForcePoll"`
 	UseKBFSKeysOnlyForTesting bool             `codec:"useKBFSKeysOnlyForTesting" json:"useKBFSKeysOnlyForTesting"`
 }
 
@@ -80,6 +81,7 @@ func (o SaltpackEncryptOptions) DeepCopy() SaltpackEncryptOptions {
 		NoSelfEncrypt:             o.NoSelfEncrypt,
 		Binary:                    o.Binary,
 		SaltpackVersion:           o.SaltpackVersion,
+		NoForcePoll:               o.NoForcePoll,
 		UseKBFSKeysOnlyForTesting: o.UseKBFSKeysOnlyForTesting,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack_ui.go
index 39748b8e..f55be0b2 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/saltpack_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/saltpack_ui.avdl
 
 package keybase1
@@ -54,6 +54,7 @@ func (e SaltpackSenderType) String() string {
 type SaltpackSender struct {
 	Uid        UID                `codec:"uid" json:"uid"`
 	Username   string             `codec:"username" json:"username"`
+	Fullname   string             `codec:"fullname" json:"fullname"`
 	SenderType SaltpackSenderType `codec:"senderType" json:"senderType"`
 }
 
@@ -61,6 +62,7 @@ func (o SaltpackSender) DeepCopy() SaltpackSender {
 	return SaltpackSender{
 		Uid:        o.Uid.DeepCopy(),
 		Username:   o.Username,
+		Fullname:   o.Fullname,
 		SenderType: o.SenderType.DeepCopy(),
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/scanproofs.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/scanproofs.go
index 61e1140d..a1dbd027 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/scanproofs.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/scanproofs.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/scanproofs.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secret_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secret_ui.go
index d48e8b48..2c67abdf 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secret_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secret_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/secret_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secretkeys.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secretkeys.go
index e7aeb754..b977ab91 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secretkeys.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/secretkeys.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/secretkeys.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/selfprovision.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/selfprovision.go
index 3a89450a..42043ff5 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/selfprovision.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/selfprovision.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/selfprovision.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/session.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/session.go
index 0c13b9e3..d094fb40 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/session.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/session.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/session.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/signup.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/signup.go
index fb8fa57a..84bca35c 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/signup.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/signup.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/signup.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/sigs.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/sigs.go
index 09abc8ca..10153141 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/sigs.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/sigs.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/sigs.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/simple_fs.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/simple_fs.go
index 0fb77019..2d96ad0a 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/simple_fs.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/simple_fs.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/simple_fs.avdl
 
 package keybase1
@@ -744,9 +744,10 @@ func (o WriteArgs) DeepCopy() WriteArgs {
 }
 
 type CopyArgs struct {
-	OpID OpID `codec:"opID" json:"opID"`
-	Src  Path `codec:"src" json:"src"`
-	Dest Path `codec:"dest" json:"dest"`
+	OpID                   OpID `codec:"opID" json:"opID"`
+	Src                    Path `codec:"src" json:"src"`
+	Dest                   Path `codec:"dest" json:"dest"`
+	OverwriteExistingFiles bool `codec:"overwriteExistingFiles" json:"overwriteExistingFiles"`
 }
 
 func (o CopyArgs) DeepCopy() CopyArgs {
@@ -754,13 +755,15 @@ func (o CopyArgs) DeepCopy() CopyArgs {
 		OpID: o.OpID.DeepCopy(),
 		Src:  o.Src.DeepCopy(),
 		Dest: o.Dest.DeepCopy(),
+		OverwriteExistingFiles: o.OverwriteExistingFiles,
 	}
 }
 
 type MoveArgs struct {
-	OpID OpID `codec:"opID" json:"opID"`
-	Src  Path `codec:"src" json:"src"`
-	Dest Path `codec:"dest" json:"dest"`
+	OpID                   OpID `codec:"opID" json:"opID"`
+	Src                    Path `codec:"src" json:"src"`
+	Dest                   Path `codec:"dest" json:"dest"`
+	OverwriteExistingFiles bool `codec:"overwriteExistingFiles" json:"overwriteExistingFiles"`
 }
 
 func (o MoveArgs) DeepCopy() MoveArgs {
@@ -768,6 +771,7 @@ func (o MoveArgs) DeepCopy() MoveArgs {
 		OpID: o.OpID.DeepCopy(),
 		Src:  o.Src.DeepCopy(),
 		Dest: o.Dest.DeepCopy(),
+		OverwriteExistingFiles: o.OverwriteExistingFiles,
 	}
 }
 
@@ -1286,12 +1290,14 @@ func (e KbfsOnlineStatus) String() string {
 type FSSettings struct {
 	SpaceAvailableNotificationThreshold int64 `codec:"spaceAvailableNotificationThreshold" json:"spaceAvailableNotificationThreshold"`
 	SfmiBannerDismissed                 bool  `codec:"sfmiBannerDismissed" json:"sfmiBannerDismissed"`
+	SyncOnCellular                      bool  `codec:"syncOnCellular" json:"syncOnCellular"`
 }
 
 func (o FSSettings) DeepCopy() FSSettings {
 	return FSSettings{
 		SpaceAvailableNotificationThreshold: o.SpaceAvailableNotificationThreshold,
 		SfmiBannerDismissed:                 o.SfmiBannerDismissed,
+		SyncOnCellular:                      o.SyncOnCellular,
 	}
 }
 
@@ -1351,6 +1357,7 @@ const (
 	SubscriptionTopic_FILES_TAB_BADGE     SubscriptionTopic = 4
 	SubscriptionTopic_OVERALL_SYNC_STATUS SubscriptionTopic = 5
 	SubscriptionTopic_SETTINGS            SubscriptionTopic = 6
+	SubscriptionTopic_UPLOAD_STATUS       SubscriptionTopic = 7
 )
 
 func (o SubscriptionTopic) DeepCopy() SubscriptionTopic { return o }
@@ -1363,6 +1370,7 @@ var SubscriptionTopicMap = map[string]SubscriptionTopic{
 	"FILES_TAB_BADGE":     4,
 	"OVERALL_SYNC_STATUS": 5,
 	"SETTINGS":            6,
+	"UPLOAD_STATUS":       7,
 }
 
 var SubscriptionTopicRevMap = map[SubscriptionTopic]string{
@@ -1373,6 +1381,7 @@ var SubscriptionTopicRevMap = map[SubscriptionTopic]string{
 	4: "FILES_TAB_BADGE",
 	5: "OVERALL_SYNC_STATUS",
 	6: "SETTINGS",
+	7: "UPLOAD_STATUS",
 }
 
 func (e SubscriptionTopic) String() string {
@@ -1480,6 +1489,28 @@ func (o DownloadStatus) DeepCopy() DownloadStatus {
 	}
 }
 
+type UploadState struct {
+	UploadID   string   `codec:"uploadID" json:"uploadID"`
+	TargetPath KBFSPath `codec:"targetPath" json:"targetPath"`
+	Error      *string  `codec:"error,omitempty" json:"error,omitempty"`
+	Canceled   bool     `codec:"canceled" json:"canceled"`
+}
+
+func (o UploadState) DeepCopy() UploadState {
+	return UploadState{
+		UploadID:   o.UploadID,
+		TargetPath: o.TargetPath.DeepCopy(),
+		Error: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Error),
+		Canceled: o.Canceled,
+	}
+}
+
 type FilesTabBadge int
 
 const (
@@ -1563,3 +1594,75 @@ func (o GUIFileContext) DeepCopy() GUIFileContext {
 		Url:         o.Url,
 	}
 }
+
+type SimpleFSSearchHit struct {
+	Path string `codec:"path" json:"path"`
+}
+
+func (o SimpleFSSearchHit) DeepCopy() SimpleFSSearchHit {
+	return SimpleFSSearchHit{
+		Path: o.Path,
+	}
+}
+
+type SimpleFSSearchResults struct {
+	Hits       []SimpleFSSearchHit `codec:"hits" json:"hits"`
+	NextResult int                 `codec:"nextResult" json:"nextResult"`
+}
+
+func (o SimpleFSSearchResults) DeepCopy() SimpleFSSearchResults {
+	return SimpleFSSearchResults{
+		Hits: (func(x []SimpleFSSearchHit) []SimpleFSSearchHit {
+			if x == nil {
+				return nil
+			}
+			ret := make([]SimpleFSSearchHit, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Hits),
+		NextResult: o.NextResult,
+	}
+}
+
+type IndexProgressRecord struct {
+	EndEstimate Time  `codec:"endEstimate" json:"endEstimate"`
+	BytesTotal  int64 `codec:"bytesTotal" json:"bytesTotal"`
+	BytesSoFar  int64 `codec:"bytesSoFar" json:"bytesSoFar"`
+}
+
+func (o IndexProgressRecord) DeepCopy() IndexProgressRecord {
+	return IndexProgressRecord{
+		EndEstimate: o.EndEstimate.DeepCopy(),
+		BytesTotal:  o.BytesTotal,
+		BytesSoFar:  o.BytesSoFar,
+	}
+}
+
+type SimpleFSIndexProgress struct {
+	OverallProgress IndexProgressRecord `codec:"overallProgress" json:"overallProgress"`
+	CurrFolder      Folder              `codec:"currFolder" json:"currFolder"`
+	CurrProgress    IndexProgressRecord `codec:"currProgress" json:"currProgress"`
+	FoldersLeft     []Folder            `codec:"foldersLeft" json:"foldersLeft"`
+}
+
+func (o SimpleFSIndexProgress) DeepCopy() SimpleFSIndexProgress {
+	return SimpleFSIndexProgress{
+		OverallProgress: o.OverallProgress.DeepCopy(),
+		CurrFolder:      o.CurrFolder.DeepCopy(),
+		CurrProgress:    o.CurrProgress.DeepCopy(),
+		FoldersLeft: (func(x []Folder) []Folder {
+			if x == nil {
+				return nil
+			}
+			ret := make([]Folder, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.FoldersLeft),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/stream_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/stream_ui.go
index ac4f43c9..05cdfbc7 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/stream_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/stream_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/stream_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teambot.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teambot.go
index e9be6638..91b5d8df 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teambot.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teambot.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/teambot.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams.go
index bc2648fa..6321489f 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/teams.avdl
 
 package keybase1
@@ -283,6 +283,12 @@ func (o TeamInviteID) DeepCopy() TeamInviteID {
 	return o
 }
 
+type TeamInviteMaxUses int
+
+func (o TeamInviteMaxUses) DeepCopy() TeamInviteMaxUses {
+	return o
+}
+
 type ReaderKeyMask struct {
 	Application TeamApplication      `codec:"application" json:"application"`
 	Generation  PerTeamKeyGeneration `codec:"generation" json:"generation"`
@@ -494,6 +500,7 @@ type TeamMemberDetails struct {
 	FullName FullName         `codec:"fullName" json:"fullName"`
 	NeedsPUK bool             `codec:"needsPUK" json:"needsPUK"`
 	Status   TeamMemberStatus `codec:"status" json:"status"`
+	JoinTime *Time            `codec:"joinTime,omitempty" json:"joinTime,omitempty"`
 }
 
 func (o TeamMemberDetails) DeepCopy() TeamMemberDetails {
@@ -503,6 +510,13 @@ func (o TeamMemberDetails) DeepCopy() TeamMemberDetails {
 		FullName: o.FullName.DeepCopy(),
 		NeedsPUK: o.NeedsPUK,
 		Status:   o.Status.DeepCopy(),
+		JoinTime: (func(x *Time) *Time {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.JoinTime),
 	}
 }
 
@@ -617,12 +631,82 @@ func (o TeamDetails) DeepCopy() TeamDetails {
 	}
 }
 
+type TeamMemberRole struct {
+	Uid      UID      `codec:"uid" json:"uid"`
+	Username string   `codec:"username" json:"username"`
+	FullName FullName `codec:"fullName" json:"fullName"`
+	Role     TeamRole `codec:"role" json:"role"`
+}
+
+func (o TeamMemberRole) DeepCopy() TeamMemberRole {
+	return TeamMemberRole{
+		Uid:      o.Uid.DeepCopy(),
+		Username: o.Username,
+		FullName: o.FullName.DeepCopy(),
+		Role:     o.Role.DeepCopy(),
+	}
+}
+
+type UntrustedTeamInfo struct {
+	Name          TeamName         `codec:"name" json:"name"`
+	InTeam        bool             `codec:"inTeam" json:"inTeam"`
+	Open          bool             `codec:"open" json:"open"`
+	Description   string           `codec:"description" json:"description"`
+	PublicAdmins  []string         `codec:"publicAdmins" json:"publicAdmins"`
+	NumMembers    int              `codec:"numMembers" json:"numMembers"`
+	PublicMembers []TeamMemberRole `codec:"publicMembers" json:"publicMembers"`
+}
+
+func (o UntrustedTeamInfo) DeepCopy() UntrustedTeamInfo {
+	return UntrustedTeamInfo{
+		Name:        o.Name.DeepCopy(),
+		InTeam:      o.InTeam,
+		Open:        o.Open,
+		Description: o.Description,
+		PublicAdmins: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.PublicAdmins),
+		NumMembers: o.NumMembers,
+		PublicMembers: (func(x []TeamMemberRole) []TeamMemberRole {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TeamMemberRole, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.PublicMembers),
+	}
+}
+
 type UserVersionPercentForm string
 
 func (o UserVersionPercentForm) DeepCopy() UserVersionPercentForm {
 	return o
 }
 
+type TeamUsedInvite struct {
+	InviteID TeamInviteID           `codec:"inviteID" json:"inviteID"`
+	Uv       UserVersionPercentForm `codec:"uv" json:"uv"`
+}
+
+func (o TeamUsedInvite) DeepCopy() TeamUsedInvite {
+	return TeamUsedInvite{
+		InviteID: o.InviteID.DeepCopy(),
+		Uv:       o.Uv.DeepCopy(),
+	}
+}
+
 type TeamChangeReq struct {
 	Owners           []UserVersion                           `codec:"owners" json:"owners"`
 	Admins           []UserVersion                           `codec:"admins" json:"admins"`
@@ -632,6 +716,7 @@ type TeamChangeReq struct {
 	RestrictedBots   map[UserVersion]TeamBotSettings         `codec:"restrictedBots" json:"restrictedBots"`
 	None             []UserVersion                           `codec:"none" json:"none"`
 	CompletedInvites map[TeamInviteID]UserVersionPercentForm `codec:"completedInvites" json:"completedInvites"`
+	UsedInvites      []TeamUsedInvite                        `codec:"usedInvites" json:"usedInvites"`
 }
 
 func (o TeamChangeReq) DeepCopy() TeamChangeReq {
@@ -726,6 +811,17 @@ func (o TeamChangeReq) DeepCopy() TeamChangeReq {
 			}
 			return ret
 		})(o.CompletedInvites),
+		UsedInvites: (func(x []TeamUsedInvite) []TeamUsedInvite {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TeamUsedInvite, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.UsedInvites),
 	}
 }
 
@@ -1384,16 +1480,18 @@ func (e AuditVersion) String() string {
 }
 
 type AuditHistory struct {
-	ID               TeamID           `codec:"ID" json:"ID"`
-	Public           bool             `codec:"public" json:"public"`
-	PriorMerkleSeqno Seqno            `codec:"priorMerkleSeqno" json:"priorMerkleSeqno"`
-	Version          AuditVersion     `codec:"version" json:"version"`
-	Audits           []Audit          `codec:"audits" json:"audits"`
-	PreProbes        map[Seqno]Probe  `codec:"preProbes" json:"preProbes"`
-	PostProbes       map[Seqno]Probe  `codec:"postProbes" json:"postProbes"`
-	Tails            map[Seqno]LinkID `codec:"tails" json:"tails"`
-	HiddenTails      map[Seqno]LinkID `codec:"hiddenTails" json:"hiddenTails"`
-	SkipUntil        Time             `codec:"skipUntil" json:"skipUntil"`
+	ID                TeamID           `codec:"ID" json:"ID"`
+	Public            bool             `codec:"public" json:"public"`
+	PriorMerkleSeqno  Seqno            `codec:"priorMerkleSeqno" json:"priorMerkleSeqno"`
+	Version           AuditVersion     `codec:"version" json:"version"`
+	Audits            []Audit          `codec:"audits" json:"audits"`
+	PreProbes         map[Seqno]Probe  `codec:"preProbes" json:"preProbes"`
+	PostProbes        map[Seqno]Probe  `codec:"postProbes" json:"postProbes"`
+	Tails             map[Seqno]LinkID `codec:"tails" json:"tails"`
+	HiddenTails       map[Seqno]LinkID `codec:"hiddenTails" json:"hiddenTails"`
+	PreProbesToRetry  []Seqno          `codec:"preProbesToRetry" json:"preProbesToRetry"`
+	PostProbesToRetry []Seqno          `codec:"postProbesToRetry" json:"postProbesToRetry"`
+	SkipUntil         Time             `codec:"skipUntil" json:"skipUntil"`
 }
 
 func (o AuditHistory) DeepCopy() AuditHistory {
@@ -1461,6 +1559,28 @@ func (o AuditHistory) DeepCopy() AuditHistory {
 			}
 			return ret
 		})(o.HiddenTails),
+		PreProbesToRetry: (func(x []Seqno) []Seqno {
+			if x == nil {
+				return nil
+			}
+			ret := make([]Seqno, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.PreProbesToRetry),
+		PostProbesToRetry: (func(x []Seqno) []Seqno {
+			if x == nil {
+				return nil
+			}
+			ret := make([]Seqno, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.PostProbesToRetry),
 		SkipUntil: o.SkipUntil.DeepCopy(),
 	}
 }
@@ -1468,25 +1588,27 @@ func (o AuditHistory) DeepCopy() AuditHistory {
 type TeamInviteCategory int
 
 const (
-	TeamInviteCategory_NONE    TeamInviteCategory = 0
-	TeamInviteCategory_UNKNOWN TeamInviteCategory = 1
-	TeamInviteCategory_KEYBASE TeamInviteCategory = 2
-	TeamInviteCategory_EMAIL   TeamInviteCategory = 3
-	TeamInviteCategory_SBS     TeamInviteCategory = 4
-	TeamInviteCategory_SEITAN  TeamInviteCategory = 5
-	TeamInviteCategory_PHONE   TeamInviteCategory = 6
+	TeamInviteCategory_NONE       TeamInviteCategory = 0
+	TeamInviteCategory_UNKNOWN    TeamInviteCategory = 1
+	TeamInviteCategory_KEYBASE    TeamInviteCategory = 2
+	TeamInviteCategory_EMAIL      TeamInviteCategory = 3
+	TeamInviteCategory_SBS        TeamInviteCategory = 4
+	TeamInviteCategory_SEITAN     TeamInviteCategory = 5
+	TeamInviteCategory_PHONE      TeamInviteCategory = 6
+	TeamInviteCategory_INVITELINK TeamInviteCategory = 7
 )
 
 func (o TeamInviteCategory) DeepCopy() TeamInviteCategory { return o }
 
 var TeamInviteCategoryMap = map[string]TeamInviteCategory{
-	"NONE":    0,
-	"UNKNOWN": 1,
-	"KEYBASE": 2,
-	"EMAIL":   3,
-	"SBS":     4,
-	"SEITAN":  5,
-	"PHONE":   6,
+	"NONE":       0,
+	"UNKNOWN":    1,
+	"KEYBASE":    2,
+	"EMAIL":      3,
+	"SBS":        4,
+	"SEITAN":     5,
+	"PHONE":      6,
+	"INVITELINK": 7,
 }
 
 var TeamInviteCategoryRevMap = map[TeamInviteCategory]string{
@@ -1497,6 +1619,7 @@ var TeamInviteCategoryRevMap = map[TeamInviteCategory]string{
 	4: "SBS",
 	5: "SEITAN",
 	6: "PHONE",
+	7: "INVITELINK",
 }
 
 func (e TeamInviteCategory) String() string {
@@ -1600,12 +1723,20 @@ func (o TeamInviteName) DeepCopy() TeamInviteName {
 	return o
 }
 
+type TeamInviteDisplayName string
+
+func (o TeamInviteDisplayName) DeepCopy() TeamInviteDisplayName {
+	return o
+}
+
 type TeamInvite struct {
-	Role    TeamRole       `codec:"role" json:"role"`
-	Id      TeamInviteID   `codec:"id" json:"id"`
-	Type    TeamInviteType `codec:"type" json:"type"`
-	Name    TeamInviteName `codec:"name" json:"name"`
-	Inviter UserVersion    `codec:"inviter" json:"inviter"`
+	Role    TeamRole           `codec:"role" json:"role"`
+	Id      TeamInviteID       `codec:"id" json:"id"`
+	Type    TeamInviteType     `codec:"type" json:"type"`
+	Name    TeamInviteName     `codec:"name" json:"name"`
+	Inviter UserVersion        `codec:"inviter" json:"inviter"`
+	MaxUses *TeamInviteMaxUses `codec:"maxUses,omitempty" json:"maxUses,omitempty"`
+	Etime   *UnixTime          `codec:"etime,omitempty" json:"etime,omitempty"`
 }
 
 func (o TeamInvite) DeepCopy() TeamInvite {
@@ -1615,32 +1746,58 @@ func (o TeamInvite) DeepCopy() TeamInvite {
 		Type:    o.Type.DeepCopy(),
 		Name:    o.Name.DeepCopy(),
 		Inviter: o.Inviter.DeepCopy(),
+		MaxUses: (func(x *TeamInviteMaxUses) *TeamInviteMaxUses {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.MaxUses),
+		Etime: (func(x *UnixTime) *UnixTime {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Etime),
 	}
 }
 
 type AnnotatedTeamInvite struct {
-	Role            TeamRole         `codec:"role" json:"role"`
-	Id              TeamInviteID     `codec:"id" json:"id"`
-	Type            TeamInviteType   `codec:"type" json:"type"`
-	Name            TeamInviteName   `codec:"name" json:"name"`
-	Uv              UserVersion      `codec:"uv" json:"uv"`
-	Inviter         UserVersion      `codec:"inviter" json:"inviter"`
-	InviterUsername string           `codec:"inviterUsername" json:"inviterUsername"`
-	TeamName        string           `codec:"teamName" json:"teamName"`
-	Status          TeamMemberStatus `codec:"status" json:"status"`
+	InviteMetadata       TeamInviteMetadata                `codec:"inviteMetadata" json:"inviteMetadata"`
+	DisplayName          TeamInviteDisplayName             `codec:"displayName" json:"displayName"`
+	InviterUsername      string                            `codec:"inviterUsername" json:"inviterUsername"`
+	InviteeUv            UserVersion                       `codec:"inviteeUv" json:"inviteeUv"`
+	TeamName             string                            `codec:"teamName" json:"teamName"`
+	Status               *TeamMemberStatus                 `codec:"status,omitempty" json:"status,omitempty"`
+	AnnotatedUsedInvites []AnnotatedTeamUsedInviteLogPoint `codec:"annotatedUsedInvites" json:"annotatedUsedInvites"`
 }
 
 func (o AnnotatedTeamInvite) DeepCopy() AnnotatedTeamInvite {
 	return AnnotatedTeamInvite{
-		Role:            o.Role.DeepCopy(),
-		Id:              o.Id.DeepCopy(),
-		Type:            o.Type.DeepCopy(),
-		Name:            o.Name.DeepCopy(),
-		Uv:              o.Uv.DeepCopy(),
-		Inviter:         o.Inviter.DeepCopy(),
+		InviteMetadata:  o.InviteMetadata.DeepCopy(),
+		DisplayName:     o.DisplayName.DeepCopy(),
 		InviterUsername: o.InviterUsername,
+		InviteeUv:       o.InviteeUv.DeepCopy(),
 		TeamName:        o.TeamName,
-		Status:          o.Status.DeepCopy(),
+		Status: (func(x *TeamMemberStatus) *TeamMemberStatus {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Status),
+		AnnotatedUsedInvites: (func(x []AnnotatedTeamUsedInviteLogPoint) []AnnotatedTeamUsedInviteLogPoint {
+			if x == nil {
+				return nil
+			}
+			ret := make([]AnnotatedTeamUsedInviteLogPoint, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.AnnotatedUsedInvites),
 	}
 }
 
@@ -1706,6 +1863,184 @@ func (o TeamLegacyTLFUpgradeChainInfo) DeepCopy() TeamLegacyTLFUpgradeChainInfo
 	}
 }
 
+type TeamSignatureMetadata struct {
+	SigMeta SignatureMetadata `codec:"sigMeta" json:"sigMeta"`
+	Uv      UserVersion       `codec:"uv" json:"uv"`
+}
+
+func (o TeamSignatureMetadata) DeepCopy() TeamSignatureMetadata {
+	return TeamSignatureMetadata{
+		SigMeta: o.SigMeta.DeepCopy(),
+		Uv:      o.Uv.DeepCopy(),
+	}
+}
+
+type TeamInviteMetadataCancel struct {
+	TeamSigMeta TeamSignatureMetadata `codec:"teamSigMeta" json:"teamSigMeta"`
+}
+
+func (o TeamInviteMetadataCancel) DeepCopy() TeamInviteMetadataCancel {
+	return TeamInviteMetadataCancel{
+		TeamSigMeta: o.TeamSigMeta.DeepCopy(),
+	}
+}
+
+type TeamInviteMetadataCompleted struct {
+	TeamSigMeta TeamSignatureMetadata `codec:"teamSigMeta" json:"teamSigMeta"`
+}
+
+func (o TeamInviteMetadataCompleted) DeepCopy() TeamInviteMetadataCompleted {
+	return TeamInviteMetadataCompleted{
+		TeamSigMeta: o.TeamSigMeta.DeepCopy(),
+	}
+}
+
+type TeamInviteMetadataStatusCode int
+
+const (
+	TeamInviteMetadataStatusCode_ACTIVE    TeamInviteMetadataStatusCode = 0
+	TeamInviteMetadataStatusCode_OBSOLETE  TeamInviteMetadataStatusCode = 1
+	TeamInviteMetadataStatusCode_CANCELLED TeamInviteMetadataStatusCode = 2
+	TeamInviteMetadataStatusCode_COMPLETED TeamInviteMetadataStatusCode = 3
+)
+
+func (o TeamInviteMetadataStatusCode) DeepCopy() TeamInviteMetadataStatusCode { return o }
+
+var TeamInviteMetadataStatusCodeMap = map[string]TeamInviteMetadataStatusCode{
+	"ACTIVE":    0,
+	"OBSOLETE":  1,
+	"CANCELLED": 2,
+	"COMPLETED": 3,
+}
+
+var TeamInviteMetadataStatusCodeRevMap = map[TeamInviteMetadataStatusCode]string{
+	0: "ACTIVE",
+	1: "OBSOLETE",
+	2: "CANCELLED",
+	3: "COMPLETED",
+}
+
+func (e TeamInviteMetadataStatusCode) String() string {
+	if v, ok := TeamInviteMetadataStatusCodeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type TeamInviteMetadataStatus struct {
+	Code__      TeamInviteMetadataStatusCode `codec:"code" json:"code"`
+	Cancelled__ *TeamInviteMetadataCancel    `codec:"cancelled,omitempty" json:"cancelled,omitempty"`
+	Completed__ *TeamInviteMetadataCompleted `codec:"completed,omitempty" json:"completed,omitempty"`
+}
+
+func (o *TeamInviteMetadataStatus) Code() (ret TeamInviteMetadataStatusCode, err error) {
+	switch o.Code__ {
+	case TeamInviteMetadataStatusCode_CANCELLED:
+		if o.Cancelled__ == nil {
+			err = errors.New("unexpected nil value for Cancelled__")
+			return ret, err
+		}
+	case TeamInviteMetadataStatusCode_COMPLETED:
+		if o.Completed__ == nil {
+			err = errors.New("unexpected nil value for Completed__")
+			return ret, err
+		}
+	}
+	return o.Code__, nil
+}
+
+func (o TeamInviteMetadataStatus) Cancelled() (res TeamInviteMetadataCancel) {
+	if o.Code__ != TeamInviteMetadataStatusCode_CANCELLED {
+		panic("wrong case accessed")
+	}
+	if o.Cancelled__ == nil {
+		return
+	}
+	return *o.Cancelled__
+}
+
+func (o TeamInviteMetadataStatus) Completed() (res TeamInviteMetadataCompleted) {
+	if o.Code__ != TeamInviteMetadataStatusCode_COMPLETED {
+		panic("wrong case accessed")
+	}
+	if o.Completed__ == nil {
+		return
+	}
+	return *o.Completed__
+}
+
+func NewTeamInviteMetadataStatusWithActive() TeamInviteMetadataStatus {
+	return TeamInviteMetadataStatus{
+		Code__: TeamInviteMetadataStatusCode_ACTIVE,
+	}
+}
+
+func NewTeamInviteMetadataStatusWithObsolete() TeamInviteMetadataStatus {
+	return TeamInviteMetadataStatus{
+		Code__: TeamInviteMetadataStatusCode_OBSOLETE,
+	}
+}
+
+func NewTeamInviteMetadataStatusWithCancelled(v TeamInviteMetadataCancel) TeamInviteMetadataStatus {
+	return TeamInviteMetadataStatus{
+		Code__:      TeamInviteMetadataStatusCode_CANCELLED,
+		Cancelled__: &v,
+	}
+}
+
+func NewTeamInviteMetadataStatusWithCompleted(v TeamInviteMetadataCompleted) TeamInviteMetadataStatus {
+	return TeamInviteMetadataStatus{
+		Code__:      TeamInviteMetadataStatusCode_COMPLETED,
+		Completed__: &v,
+	}
+}
+
+func (o TeamInviteMetadataStatus) DeepCopy() TeamInviteMetadataStatus {
+	return TeamInviteMetadataStatus{
+		Code__: o.Code__.DeepCopy(),
+		Cancelled__: (func(x *TeamInviteMetadataCancel) *TeamInviteMetadataCancel {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Cancelled__),
+		Completed__: (func(x *TeamInviteMetadataCompleted) *TeamInviteMetadataCompleted {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Completed__),
+	}
+}
+
+type TeamInviteMetadata struct {
+	Invite      TeamInvite               `codec:"invite" json:"invite"`
+	TeamSigMeta TeamSignatureMetadata    `codec:"teamSigMeta" json:"teamSigMeta"`
+	Status      TeamInviteMetadataStatus `codec:"status" json:"status"`
+	UsedInvites []TeamUsedInviteLogPoint `codec:"usedInvites" json:"usedInvites"`
+}
+
+func (o TeamInviteMetadata) DeepCopy() TeamInviteMetadata {
+	return TeamInviteMetadata{
+		Invite:      o.Invite.DeepCopy(),
+		TeamSigMeta: o.TeamSigMeta.DeepCopy(),
+		Status:      o.Status.DeepCopy(),
+		UsedInvites: (func(x []TeamUsedInviteLogPoint) []TeamUsedInviteLogPoint {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TeamUsedInviteLogPoint, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.UsedInvites),
+	}
+}
+
 type TeamSigChainState struct {
 	Reader                  UserVersion                                       `codec:"reader" json:"reader"`
 	Id                      TeamID                                            `codec:"id" json:"id"`
@@ -1726,8 +2061,7 @@ type TeamSigChainState struct {
 	PerTeamKeyCTime         UnixTime                                          `codec:"perTeamKeyCTime" json:"perTeamKeyCTime"`
 	LinkIDs                 map[Seqno]LinkID                                  `codec:"linkIDs" json:"linkIDs"`
 	StubbedLinks            map[Seqno]bool                                    `codec:"stubbedLinks" json:"stubbedLinks"`
-	ActiveInvites           map[TeamInviteID]TeamInvite                       `codec:"activeInvites" json:"activeInvites"`
-	ObsoleteInvites         map[TeamInviteID]TeamInvite                       `codec:"obsoleteInvites" json:"obsoleteInvites"`
+	InviteMetadatas         map[TeamInviteID]TeamInviteMetadata               `codec:"inviteMetadatas" json:"inviteMetadatas"`
 	Open                    bool                                              `codec:"open" json:"open"`
 	OpenTeamJoinAs          TeamRole                                          `codec:"openTeamJoinAs" json:"openTeamJoinAs"`
 	Bots                    map[UserVersion]TeamBotSettings                   `codec:"bots" json:"bots"`
@@ -1849,30 +2183,18 @@ func (o TeamSigChainState) DeepCopy() TeamSigChainState {
 			}
 			return ret
 		})(o.StubbedLinks),
-		ActiveInvites: (func(x map[TeamInviteID]TeamInvite) map[TeamInviteID]TeamInvite {
-			if x == nil {
-				return nil
-			}
-			ret := make(map[TeamInviteID]TeamInvite, len(x))
-			for k, v := range x {
-				kCopy := k.DeepCopy()
-				vCopy := v.DeepCopy()
-				ret[kCopy] = vCopy
-			}
-			return ret
-		})(o.ActiveInvites),
-		ObsoleteInvites: (func(x map[TeamInviteID]TeamInvite) map[TeamInviteID]TeamInvite {
+		InviteMetadatas: (func(x map[TeamInviteID]TeamInviteMetadata) map[TeamInviteID]TeamInviteMetadata {
 			if x == nil {
 				return nil
 			}
-			ret := make(map[TeamInviteID]TeamInvite, len(x))
+			ret := make(map[TeamInviteID]TeamInviteMetadata, len(x))
 			for k, v := range x {
 				kCopy := k.DeepCopy()
 				vCopy := v.DeepCopy()
 				ret[kCopy] = vCopy
 			}
 			return ret
-		})(o.ObsoleteInvites),
+		})(o.InviteMetadatas),
 		Open:           o.Open,
 		OpenTeamJoinAs: o.OpenTeamJoinAs.DeepCopy(),
 		Bots: (func(x map[UserVersion]TeamBotSettings) map[UserVersion]TeamBotSettings {
@@ -1962,6 +2284,30 @@ func (o UserLogPoint) DeepCopy() UserLogPoint {
 	}
 }
 
+type AnnotatedTeamUsedInviteLogPoint struct {
+	Username               string                 `codec:"username" json:"username"`
+	TeamUsedInviteLogPoint TeamUsedInviteLogPoint `codec:"teamUsedInviteLogPoint" json:"teamUsedInviteLogPoint"`
+}
+
+func (o AnnotatedTeamUsedInviteLogPoint) DeepCopy() AnnotatedTeamUsedInviteLogPoint {
+	return AnnotatedTeamUsedInviteLogPoint{
+		Username:               o.Username,
+		TeamUsedInviteLogPoint: o.TeamUsedInviteLogPoint.DeepCopy(),
+	}
+}
+
+type TeamUsedInviteLogPoint struct {
+	Uv       UserVersion `codec:"uv" json:"uv"`
+	LogPoint int         `codec:"logPoint" json:"logPoint"`
+}
+
+func (o TeamUsedInviteLogPoint) DeepCopy() TeamUsedInviteLogPoint {
+	return TeamUsedInviteLogPoint{
+		Uv:       o.Uv.DeepCopy(),
+		LogPoint: o.LogPoint,
+	}
+}
+
 type SubteamLogPoint struct {
 	Name  TeamName `codec:"name" json:"name"`
 	Seqno Seqno    `codec:"seqno" json:"seqno"`
@@ -2077,7 +2423,7 @@ type TeamChangeRow struct {
 	MembershipChanged   bool   `codec:"membershipChanged" json:"membership_changed"`
 	LatestSeqno         Seqno  `codec:"latestSeqno" json:"latest_seqno"`
 	LatestHiddenSeqno   Seqno  `codec:"latestHiddenSeqno" json:"latest_hidden_seqno"`
-	LatestOffchainSeqno Seqno  `codec:"latestOffchainSeqno" json:"latest_offchain_seqno"`
+	LatestOffchainSeqno Seqno  `codec:"latestOffchainSeqno" json:"latest_offchain_version"`
 	ImplicitTeam        bool   `codec:"implicitTeam" json:"implicit_team"`
 	Misc                bool   `codec:"misc" json:"misc"`
 	RemovedResetUsers   bool   `codec:"removedResetUsers" json:"removed_reset_users"`
@@ -2206,6 +2552,12 @@ func (o SeitanIKey) DeepCopy() SeitanIKey {
 	return o
 }
 
+type SeitanIKeyInvitelink string
+
+func (o SeitanIKeyInvitelink) DeepCopy() SeitanIKeyInvitelink {
+	return o
+}
+
 type SeitanPubKey string
 
 func (o SeitanPubKey) DeepCopy() SeitanPubKey {
@@ -2221,20 +2573,23 @@ func (o SeitanIKeyV2) DeepCopy() SeitanIKeyV2 {
 type SeitanKeyAndLabelVersion int
 
 const (
-	SeitanKeyAndLabelVersion_V1 SeitanKeyAndLabelVersion = 1
-	SeitanKeyAndLabelVersion_V2 SeitanKeyAndLabelVersion = 2
+	SeitanKeyAndLabelVersion_V1         SeitanKeyAndLabelVersion = 1
+	SeitanKeyAndLabelVersion_V2         SeitanKeyAndLabelVersion = 2
+	SeitanKeyAndLabelVersion_Invitelink SeitanKeyAndLabelVersion = 3
 )
 
 func (o SeitanKeyAndLabelVersion) DeepCopy() SeitanKeyAndLabelVersion { return o }
 
 var SeitanKeyAndLabelVersionMap = map[string]SeitanKeyAndLabelVersion{
-	"V1": 1,
-	"V2": 2,
+	"V1":         1,
+	"V2":         2,
+	"Invitelink": 3,
 }
 
 var SeitanKeyAndLabelVersionRevMap = map[SeitanKeyAndLabelVersion]string{
 	1: "V1",
 	2: "V2",
+	3: "Invitelink",
 }
 
 func (e SeitanKeyAndLabelVersion) String() string {
@@ -2245,9 +2600,10 @@ func (e SeitanKeyAndLabelVersion) String() string {
 }
 
 type SeitanKeyAndLabel struct {
-	V__  SeitanKeyAndLabelVersion   `codec:"v" json:"v"`
-	V1__ *SeitanKeyAndLabelVersion1 `codec:"v1,omitempty" json:"v1,omitempty"`
-	V2__ *SeitanKeyAndLabelVersion2 `codec:"v2,omitempty" json:"v2,omitempty"`
+	V__          SeitanKeyAndLabelVersion     `codec:"v" json:"v"`
+	V1__         *SeitanKeyAndLabelVersion1   `codec:"v1,omitempty" json:"v1,omitempty"`
+	V2__         *SeitanKeyAndLabelVersion2   `codec:"v2,omitempty" json:"v2,omitempty"`
+	Invitelink__ *SeitanKeyAndLabelInvitelink `codec:"invitelink,omitempty" json:"invitelink,omitempty"`
 }
 
 func (o *SeitanKeyAndLabel) V() (ret SeitanKeyAndLabelVersion, err error) {
@@ -2262,6 +2618,11 @@ func (o *SeitanKeyAndLabel) V() (ret SeitanKeyAndLabelVersion, err error) {
 			err = errors.New("unexpected nil value for V2__")
 			return ret, err
 		}
+	case SeitanKeyAndLabelVersion_Invitelink:
+		if o.Invitelink__ == nil {
+			err = errors.New("unexpected nil value for Invitelink__")
+			return ret, err
+		}
 	}
 	return o.V__, nil
 }
@@ -2286,6 +2647,16 @@ func (o SeitanKeyAndLabel) V2() (res SeitanKeyAndLabelVersion2) {
 	return *o.V2__
 }
 
+func (o SeitanKeyAndLabel) Invitelink() (res SeitanKeyAndLabelInvitelink) {
+	if o.V__ != SeitanKeyAndLabelVersion_Invitelink {
+		panic("wrong case accessed")
+	}
+	if o.Invitelink__ == nil {
+		return
+	}
+	return *o.Invitelink__
+}
+
 func NewSeitanKeyAndLabelWithV1(v SeitanKeyAndLabelVersion1) SeitanKeyAndLabel {
 	return SeitanKeyAndLabel{
 		V__:  SeitanKeyAndLabelVersion_V1,
@@ -2300,6 +2671,13 @@ func NewSeitanKeyAndLabelWithV2(v SeitanKeyAndLabelVersion2) SeitanKeyAndLabel {
 	}
 }
 
+func NewSeitanKeyAndLabelWithInvitelink(v SeitanKeyAndLabelInvitelink) SeitanKeyAndLabel {
+	return SeitanKeyAndLabel{
+		V__:          SeitanKeyAndLabelVersion_Invitelink,
+		Invitelink__: &v,
+	}
+}
+
 func NewSeitanKeyAndLabelDefault(v SeitanKeyAndLabelVersion) SeitanKeyAndLabel {
 	return SeitanKeyAndLabel{
 		V__: v,
@@ -2323,6 +2701,13 @@ func (o SeitanKeyAndLabel) DeepCopy() SeitanKeyAndLabel {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.V2__),
+		Invitelink__: (func(x *SeitanKeyAndLabelInvitelink) *SeitanKeyAndLabelInvitelink {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Invitelink__),
 	}
 }
 
@@ -2350,20 +2735,35 @@ func (o SeitanKeyAndLabelVersion2) DeepCopy() SeitanKeyAndLabelVersion2 {
 	}
 }
 
+type SeitanKeyAndLabelInvitelink struct {
+	I SeitanIKeyInvitelink `codec:"i" json:"i"`
+	L SeitanKeyLabel       `codec:"l" json:"l"`
+}
+
+func (o SeitanKeyAndLabelInvitelink) DeepCopy() SeitanKeyAndLabelInvitelink {
+	return SeitanKeyAndLabelInvitelink{
+		I: o.I.DeepCopy(),
+		L: o.L.DeepCopy(),
+	}
+}
+
 type SeitanKeyLabelType int
 
 const (
-	SeitanKeyLabelType_SMS SeitanKeyLabelType = 1
+	SeitanKeyLabelType_SMS     SeitanKeyLabelType = 1
+	SeitanKeyLabelType_GENERIC SeitanKeyLabelType = 2
 )
 
 func (o SeitanKeyLabelType) DeepCopy() SeitanKeyLabelType { return o }
 
 var SeitanKeyLabelTypeMap = map[string]SeitanKeyLabelType{
-	"SMS": 1,
+	"SMS":     1,
+	"GENERIC": 2,
 }
 
 var SeitanKeyLabelTypeRevMap = map[SeitanKeyLabelType]string{
 	1: "SMS",
+	2: "GENERIC",
 }
 
 func (e SeitanKeyLabelType) String() string {
@@ -2374,8 +2774,9 @@ func (e SeitanKeyLabelType) String() string {
 }
 
 type SeitanKeyLabel struct {
-	T__   SeitanKeyLabelType `codec:"t" json:"t"`
-	Sms__ *SeitanKeyLabelSms `codec:"sms,omitempty" json:"sms,omitempty"`
+	T__       SeitanKeyLabelType     `codec:"t" json:"t"`
+	Sms__     *SeitanKeyLabelSms     `codec:"sms,omitempty" json:"sms,omitempty"`
+	Generic__ *SeitanKeyLabelGeneric `codec:"generic,omitempty" json:"generic,omitempty"`
 }
 
 func (o *SeitanKeyLabel) T() (ret SeitanKeyLabelType, err error) {
@@ -2385,6 +2786,11 @@ func (o *SeitanKeyLabel) T() (ret SeitanKeyLabelType, err error) {
 			err = errors.New("unexpected nil value for Sms__")
 			return ret, err
 		}
+	case SeitanKeyLabelType_GENERIC:
+		if o.Generic__ == nil {
+			err = errors.New("unexpected nil value for Generic__")
+			return ret, err
+		}
 	}
 	return o.T__, nil
 }
@@ -2399,6 +2805,16 @@ func (o SeitanKeyLabel) Sms() (res SeitanKeyLabelSms) {
 	return *o.Sms__
 }
 
+func (o SeitanKeyLabel) Generic() (res SeitanKeyLabelGeneric) {
+	if o.T__ != SeitanKeyLabelType_GENERIC {
+		panic("wrong case accessed")
+	}
+	if o.Generic__ == nil {
+		return
+	}
+	return *o.Generic__
+}
+
 func NewSeitanKeyLabelWithSms(v SeitanKeyLabelSms) SeitanKeyLabel {
 	return SeitanKeyLabel{
 		T__:   SeitanKeyLabelType_SMS,
@@ -2406,6 +2822,13 @@ func NewSeitanKeyLabelWithSms(v SeitanKeyLabelSms) SeitanKeyLabel {
 	}
 }
 
+func NewSeitanKeyLabelWithGeneric(v SeitanKeyLabelGeneric) SeitanKeyLabel {
+	return SeitanKeyLabel{
+		T__:       SeitanKeyLabelType_GENERIC,
+		Generic__: &v,
+	}
+}
+
 func NewSeitanKeyLabelDefault(t SeitanKeyLabelType) SeitanKeyLabel {
 	return SeitanKeyLabel{
 		T__: t,
@@ -2422,6 +2845,13 @@ func (o SeitanKeyLabel) DeepCopy() SeitanKeyLabel {
 			tmp := (*x).DeepCopy()
 			return &tmp
 		})(o.Sms__),
+		Generic__: (func(x *SeitanKeyLabelGeneric) *SeitanKeyLabelGeneric {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Generic__),
 	}
 }
 
@@ -2437,6 +2867,16 @@ func (o SeitanKeyLabelSms) DeepCopy() SeitanKeyLabelSms {
 	}
 }
 
+type SeitanKeyLabelGeneric struct {
+	L string `codec:"l" json:"l"`
+}
+
+func (o SeitanKeyLabelGeneric) DeepCopy() SeitanKeyLabelGeneric {
+	return SeitanKeyLabelGeneric{
+		L: o.L,
+	}
+}
+
 type TeamSeitanRequest struct {
 	InviteID    TeamInviteID `codec:"inviteID" json:"invite_id"`
 	Uid         UID          `codec:"uid" json:"uid"`
@@ -2877,14 +3317,18 @@ func (o TeamAddMembersResult) DeepCopy() TeamAddMembersResult {
 }
 
 type TeamJoinRequest struct {
-	Name     string `codec:"name" json:"name"`
-	Username string `codec:"username" json:"username"`
+	Name     string   `codec:"name" json:"name"`
+	Username string   `codec:"username" json:"username"`
+	FullName FullName `codec:"fullName" json:"fullName"`
+	Ctime    UnixTime `codec:"ctime" json:"ctime"`
 }
 
 func (o TeamJoinRequest) DeepCopy() TeamJoinRequest {
 	return TeamJoinRequest{
 		Name:     o.Name,
 		Username: o.Username,
+		FullName: o.FullName.DeepCopy(),
+		Ctime:    o.Ctime.DeepCopy(),
 	}
 }
 
@@ -3082,16 +3526,104 @@ func (o TeamAndMemberShowcase) DeepCopy() TeamAndMemberShowcase {
 	}
 }
 
+type TeamAvatar struct {
+	AvatarFilename string         `codec:"avatarFilename" json:"avatarFilename"`
+	Crop           *ImageCropRect `codec:"crop,omitempty" json:"crop,omitempty"`
+}
+
+func (o TeamAvatar) DeepCopy() TeamAvatar {
+	return TeamAvatar{
+		AvatarFilename: o.AvatarFilename,
+		Crop: (func(x *ImageCropRect) *ImageCropRect {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Crop),
+	}
+}
+
+type TeamCreateFancyInfo struct {
+	Name               string         `codec:"name" json:"name"`
+	Description        string         `codec:"description" json:"description"`
+	JoinSubteam        bool           `codec:"joinSubteam" json:"joinSubteam"`
+	OpenSettings       TeamSettings   `codec:"openSettings" json:"openSettings"`
+	Showcase           bool           `codec:"showcase" json:"showcase"`
+	Avatar             *TeamAvatar    `codec:"avatar,omitempty" json:"avatar,omitempty"`
+	ChatChannels       []string       `codec:"chatChannels" json:"chatChannels"`
+	Subteams           []string       `codec:"subteams" json:"subteams"`
+	Users              []UserRolePair `codec:"users" json:"users"`
+	EmailInviteMessage *string        `codec:"emailInviteMessage,omitempty" json:"emailInviteMessage,omitempty"`
+}
+
+func (o TeamCreateFancyInfo) DeepCopy() TeamCreateFancyInfo {
+	return TeamCreateFancyInfo{
+		Name:         o.Name,
+		Description:  o.Description,
+		JoinSubteam:  o.JoinSubteam,
+		OpenSettings: o.OpenSettings.DeepCopy(),
+		Showcase:     o.Showcase,
+		Avatar: (func(x *TeamAvatar) *TeamAvatar {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Avatar),
+		ChatChannels: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.ChatChannels),
+		Subteams: (func(x []string) []string {
+			if x == nil {
+				return nil
+			}
+			ret := make([]string, len(x))
+			for i, v := range x {
+				vCopy := v
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Subteams),
+		Users: (func(x []UserRolePair) []UserRolePair {
+			if x == nil {
+				return nil
+			}
+			ret := make([]UserRolePair, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Users),
+		EmailInviteMessage: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.EmailInviteMessage),
+	}
+}
+
 type UserRolePair struct {
-	AssertionOrEmail string           `codec:"assertionOrEmail" json:"assertionOrEmail"`
-	Role             TeamRole         `codec:"role" json:"role"`
-	BotSettings      *TeamBotSettings `codec:"botSettings,omitempty" json:"botSettings,omitempty"`
+	Assertion   string           `codec:"assertion" json:"assertion"`
+	Role        TeamRole         `codec:"role" json:"role"`
+	BotSettings *TeamBotSettings `codec:"botSettings,omitempty" json:"botSettings,omitempty"`
 }
 
 func (o UserRolePair) DeepCopy() UserRolePair {
 	return UserRolePair{
-		AssertionOrEmail: o.AssertionOrEmail,
-		Role:             o.Role.DeepCopy(),
+		Assertion: o.Assertion,
+		Role:      o.Role.DeepCopy(),
 		BotSettings: (func(x *TeamBotSettings) *TeamBotSettings {
 			if x == nil {
 				return nil
@@ -3102,36 +3634,226 @@ func (o UserRolePair) DeepCopy() UserRolePair {
 	}
 }
 
-type BulkRes struct {
-	Invited        []string `codec:"invited" json:"invited"`
-	AlreadyInvited []string `codec:"alreadyInvited" json:"alreadyInvited"`
-	Malformed      []string `codec:"malformed" json:"malformed"`
+type AssertionTeamMemberToRemove struct {
+	Assertion         string `codec:"assertion" json:"assertion"`
+	RemoveFromSubtree bool   `codec:"removeFromSubtree" json:"removeFromSubtree"`
 }
 
-func (o BulkRes) DeepCopy() BulkRes {
-	return BulkRes{
-		Invited: (func(x []string) []string {
+func (o AssertionTeamMemberToRemove) DeepCopy() AssertionTeamMemberToRemove {
+	return AssertionTeamMemberToRemove{
+		Assertion:         o.Assertion,
+		RemoveFromSubtree: o.RemoveFromSubtree,
+	}
+}
+
+type InviteTeamMemberToRemove struct {
+	InviteID TeamInviteID `codec:"inviteID" json:"inviteID"`
+}
+
+func (o InviteTeamMemberToRemove) DeepCopy() InviteTeamMemberToRemove {
+	return InviteTeamMemberToRemove{
+		InviteID: o.InviteID.DeepCopy(),
+	}
+}
+
+type TeamMemberToRemoveType int
+
+const (
+	TeamMemberToRemoveType_ASSERTION TeamMemberToRemoveType = 0
+	TeamMemberToRemoveType_INVITEID  TeamMemberToRemoveType = 1
+)
+
+func (o TeamMemberToRemoveType) DeepCopy() TeamMemberToRemoveType { return o }
+
+var TeamMemberToRemoveTypeMap = map[string]TeamMemberToRemoveType{
+	"ASSERTION": 0,
+	"INVITEID":  1,
+}
+
+var TeamMemberToRemoveTypeRevMap = map[TeamMemberToRemoveType]string{
+	0: "ASSERTION",
+	1: "INVITEID",
+}
+
+func (e TeamMemberToRemoveType) String() string {
+	if v, ok := TeamMemberToRemoveTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type TeamMemberToRemove struct {
+	Type__      TeamMemberToRemoveType       `codec:"type" json:"type"`
+	Assertion__ *AssertionTeamMemberToRemove `codec:"assertion,omitempty" json:"assertion,omitempty"`
+	Inviteid__  *InviteTeamMemberToRemove    `codec:"inviteid,omitempty" json:"inviteid,omitempty"`
+}
+
+func (o *TeamMemberToRemove) Type() (ret TeamMemberToRemoveType, err error) {
+	switch o.Type__ {
+	case TeamMemberToRemoveType_ASSERTION:
+		if o.Assertion__ == nil {
+			err = errors.New("unexpected nil value for Assertion__")
+			return ret, err
+		}
+	case TeamMemberToRemoveType_INVITEID:
+		if o.Inviteid__ == nil {
+			err = errors.New("unexpected nil value for Inviteid__")
+			return ret, err
+		}
+	}
+	return o.Type__, nil
+}
+
+func (o TeamMemberToRemove) Assertion() (res AssertionTeamMemberToRemove) {
+	if o.Type__ != TeamMemberToRemoveType_ASSERTION {
+		panic("wrong case accessed")
+	}
+	if o.Assertion__ == nil {
+		return
+	}
+	return *o.Assertion__
+}
+
+func (o TeamMemberToRemove) Inviteid() (res InviteTeamMemberToRemove) {
+	if o.Type__ != TeamMemberToRemoveType_INVITEID {
+		panic("wrong case accessed")
+	}
+	if o.Inviteid__ == nil {
+		return
+	}
+	return *o.Inviteid__
+}
+
+func NewTeamMemberToRemoveWithAssertion(v AssertionTeamMemberToRemove) TeamMemberToRemove {
+	return TeamMemberToRemove{
+		Type__:      TeamMemberToRemoveType_ASSERTION,
+		Assertion__: &v,
+	}
+}
+
+func NewTeamMemberToRemoveWithInviteid(v InviteTeamMemberToRemove) TeamMemberToRemove {
+	return TeamMemberToRemove{
+		Type__:     TeamMemberToRemoveType_INVITEID,
+		Inviteid__: &v,
+	}
+}
+
+func (o TeamMemberToRemove) DeepCopy() TeamMemberToRemove {
+	return TeamMemberToRemove{
+		Type__: o.Type__.DeepCopy(),
+		Assertion__: (func(x *AssertionTeamMemberToRemove) *AssertionTeamMemberToRemove {
 			if x == nil {
 				return nil
 			}
-			ret := make([]string, len(x))
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Assertion__),
+		Inviteid__: (func(x *InviteTeamMemberToRemove) *InviteTeamMemberToRemove {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Inviteid__),
+	}
+}
+
+type RemoveTeamMemberFailure struct {
+	TeamMember     TeamMemberToRemove `codec:"teamMember" json:"teamMember"`
+	ErrorAtTarget  *string            `codec:"errorAtTarget,omitempty" json:"errorAtTarget,omitempty"`
+	ErrorAtSubtree *string            `codec:"errorAtSubtree,omitempty" json:"errorAtSubtree,omitempty"`
+}
+
+func (o RemoveTeamMemberFailure) DeepCopy() RemoveTeamMemberFailure {
+	return RemoveTeamMemberFailure{
+		TeamMember: o.TeamMember.DeepCopy(),
+		ErrorAtTarget: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ErrorAtTarget),
+		ErrorAtSubtree: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.ErrorAtSubtree),
+	}
+}
+
+type TeamRemoveMembersResult struct {
+	Failures []RemoveTeamMemberFailure `codec:"failures" json:"failures"`
+}
+
+func (o TeamRemoveMembersResult) DeepCopy() TeamRemoveMembersResult {
+	return TeamRemoveMembersResult{
+		Failures: (func(x []RemoveTeamMemberFailure) []RemoveTeamMemberFailure {
+			if x == nil {
+				return nil
+			}
+			ret := make([]RemoveTeamMemberFailure, len(x))
 			for i, v := range x {
-				vCopy := v
+				vCopy := v.DeepCopy()
 				ret[i] = vCopy
 			}
 			return ret
-		})(o.Invited),
-		AlreadyInvited: (func(x []string) []string {
+		})(o.Failures),
+	}
+}
+
+type TeamEditMembersResult struct {
+	Failures []UserRolePair `codec:"failures" json:"failures"`
+}
+
+func (o TeamEditMembersResult) DeepCopy() TeamEditMembersResult {
+	return TeamEditMembersResult{
+		Failures: (func(x []UserRolePair) []UserRolePair {
 			if x == nil {
 				return nil
 			}
-			ret := make([]string, len(x))
+			ret := make([]UserRolePair, len(x))
 			for i, v := range x {
-				vCopy := v
+				vCopy := v.DeepCopy()
 				ret[i] = vCopy
 			}
 			return ret
-		})(o.AlreadyInvited),
+		})(o.Failures),
+	}
+}
+
+type UntrustedTeamExistsResult struct {
+	Exists bool       `codec:"exists" json:"exists"`
+	Status StatusCode `codec:"status" json:"status"`
+}
+
+func (o UntrustedTeamExistsResult) DeepCopy() UntrustedTeamExistsResult {
+	return UntrustedTeamExistsResult{
+		Exists: o.Exists,
+		Status: o.Status.DeepCopy(),
+	}
+}
+
+type Invitelink struct {
+	Ikey SeitanIKeyInvitelink `codec:"ikey" json:"ikey"`
+	Url  string               `codec:"url" json:"url"`
+}
+
+func (o Invitelink) DeepCopy() Invitelink {
+	return Invitelink{
+		Ikey: o.Ikey.DeepCopy(),
+		Url:  o.Url,
+	}
+}
+
+type BulkRes struct {
+	Malformed []string `codec:"malformed" json:"malformed"`
+}
+
+func (o BulkRes) DeepCopy() BulkRes {
+	return BulkRes{
 		Malformed: (func(x []string) []string {
 			if x == nil {
 				return nil
@@ -3146,6 +3868,47 @@ func (o BulkRes) DeepCopy() BulkRes {
 	}
 }
 
+type InviteLinkDetails struct {
+	InviteID          TeamInviteID               `codec:"inviteID" json:"inviteID"`
+	InviterResetOrDel bool                       `codec:"inviterResetOrDel" json:"inviterResetOrDel"`
+	InviterUID        UID                        `codec:"inviterUID" json:"inviterUID"`
+	InviterUsername   string                     `codec:"inviterUsername" json:"inviterUsername"`
+	IsMember          bool                       `codec:"isMember" json:"isMember"`
+	TeamAvatars       map[AvatarFormat]AvatarUrl `codec:"teamAvatars" json:"teamAvatars"`
+	TeamDesc          string                     `codec:"teamDesc" json:"teamDesc"`
+	TeamID            TeamID                     `codec:"teamID" json:"teamID"`
+	TeamIsOpen        bool                       `codec:"teamIsOpen" json:"teamIsOpen"`
+	TeamName          TeamName                   `codec:"teamName" json:"teamName"`
+	TeamNumMembers    int                        `codec:"teamNumMembers" json:"teamNumMembers"`
+}
+
+func (o InviteLinkDetails) DeepCopy() InviteLinkDetails {
+	return InviteLinkDetails{
+		InviteID:          o.InviteID.DeepCopy(),
+		InviterResetOrDel: o.InviterResetOrDel,
+		InviterUID:        o.InviterUID.DeepCopy(),
+		InviterUsername:   o.InviterUsername,
+		IsMember:          o.IsMember,
+		TeamAvatars: (func(x map[AvatarFormat]AvatarUrl) map[AvatarFormat]AvatarUrl {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[AvatarFormat]AvatarUrl, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.TeamAvatars),
+		TeamDesc:       o.TeamDesc,
+		TeamID:         o.TeamID.DeepCopy(),
+		TeamIsOpen:     o.TeamIsOpen,
+		TeamName:       o.TeamName.DeepCopy(),
+		TeamNumMembers: o.TeamNumMembers,
+	}
+}
+
 type ImplicitTeamUserSet struct {
 	KeybaseUsers    []string          `codec:"keybaseUsers" json:"keybaseUsers"`
 	UnresolvedUsers []SocialAssertion `codec:"unresolvedUsers" json:"unresolvedUsers"`
@@ -3256,10 +4019,12 @@ type TeamOperation struct {
 	ListFirst              bool `codec:"listFirst" json:"listFirst"`
 	ChangeTarsDisabled     bool `codec:"changeTarsDisabled" json:"changeTarsDisabled"`
 	DeleteChatHistory      bool `codec:"deleteChatHistory" json:"deleteChatHistory"`
+	DeleteOtherEmojis      bool `codec:"deleteOtherEmojis" json:"deleteOtherEmojis"`
 	DeleteOtherMessages    bool `codec:"deleteOtherMessages" json:"deleteOtherMessages"`
 	DeleteTeam             bool `codec:"deleteTeam" json:"deleteTeam"`
 	PinMessage             bool `codec:"pinMessage" json:"pinMessage"`
 	ManageBots             bool `codec:"manageBots" json:"manageBots"`
+	ManageEmojis           bool `codec:"manageEmojis" json:"manageEmojis"`
 }
 
 func (o TeamOperation) DeepCopy() TeamOperation {
@@ -3284,10 +4049,12 @@ func (o TeamOperation) DeepCopy() TeamOperation {
 		ListFirst:              o.ListFirst,
 		ChangeTarsDisabled:     o.ChangeTarsDisabled,
 		DeleteChatHistory:      o.DeleteChatHistory,
+		DeleteOtherEmojis:      o.DeleteOtherEmojis,
 		DeleteOtherMessages:    o.DeleteOtherMessages,
 		DeleteTeam:             o.DeleteTeam,
 		PinMessage:             o.PinMessage,
 		ManageBots:             o.ManageBots,
+		ManageEmojis:           o.ManageEmojis,
 	}
 }
 
@@ -3462,7 +4229,6 @@ type AnnotatedTeam struct {
 	Members                      []AnnotatedTeamMemberDetails `codec:"members" json:"members"`
 	Invites                      []AnnotatedTeamInvite        `codec:"invites" json:"invites"`
 	JoinRequests                 []TeamJoinRequest            `codec:"joinRequests" json:"joinRequests"`
-	UserIsShowcasing             bool                         `codec:"userIsShowcasing" json:"userIsShowcasing"`
 	TarsDisabled                 bool                         `codec:"tarsDisabled" json:"tarsDisabled"`
 	Settings                     TeamSettings                 `codec:"settings" json:"settings"`
 	Showcase                     TeamShowcase                 `codec:"showcase" json:"showcase"`
@@ -3470,8 +4236,8 @@ type AnnotatedTeam struct {
 
 func (o AnnotatedTeam) DeepCopy() AnnotatedTeam {
 	return AnnotatedTeam{
-		TeamID:                       o.TeamID.DeepCopy(),
-		Name:                         o.Name,
+		TeamID: o.TeamID.DeepCopy(),
+		Name:   o.Name,
 		TransitiveSubteamsUnverified: o.TransitiveSubteamsUnverified.DeepCopy(),
 		Members: (func(x []AnnotatedTeamMemberDetails) []AnnotatedTeamMemberDetails {
 			if x == nil {
@@ -3506,9 +4272,197 @@ func (o AnnotatedTeam) DeepCopy() AnnotatedTeam {
 			}
 			return ret
 		})(o.JoinRequests),
-		UserIsShowcasing: o.UserIsShowcasing,
-		TarsDisabled:     o.TarsDisabled,
-		Settings:         o.Settings.DeepCopy(),
-		Showcase:         o.Showcase.DeepCopy(),
+		TarsDisabled: o.TarsDisabled,
+		Settings:     o.Settings.DeepCopy(),
+		Showcase:     o.Showcase.DeepCopy(),
+	}
+}
+
+type TeamTreeMembershipValue struct {
+	Role     TeamRole `codec:"role" json:"role"`
+	JoinTime *Time    `codec:"joinTime,omitempty" json:"joinTime,omitempty"`
+	TeamID   TeamID   `codec:"teamID" json:"teamID"`
+}
+
+func (o TeamTreeMembershipValue) DeepCopy() TeamTreeMembershipValue {
+	return TeamTreeMembershipValue{
+		Role: o.Role.DeepCopy(),
+		JoinTime: (func(x *Time) *Time {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.JoinTime),
+		TeamID: o.TeamID.DeepCopy(),
+	}
+}
+
+type TeamTreeMembershipStatus int
+
+const (
+	TeamTreeMembershipStatus_OK     TeamTreeMembershipStatus = 0
+	TeamTreeMembershipStatus_ERROR  TeamTreeMembershipStatus = 1
+	TeamTreeMembershipStatus_HIDDEN TeamTreeMembershipStatus = 2
+)
+
+func (o TeamTreeMembershipStatus) DeepCopy() TeamTreeMembershipStatus { return o }
+
+var TeamTreeMembershipStatusMap = map[string]TeamTreeMembershipStatus{
+	"OK":     0,
+	"ERROR":  1,
+	"HIDDEN": 2,
+}
+
+var TeamTreeMembershipStatusRevMap = map[TeamTreeMembershipStatus]string{
+	0: "OK",
+	1: "ERROR",
+	2: "HIDDEN",
+}
+
+func (e TeamTreeMembershipStatus) String() string {
+	if v, ok := TeamTreeMembershipStatusRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type TeamTreeError struct {
+	Message           string `codec:"message" json:"message"`
+	WillSkipSubtree   bool   `codec:"willSkipSubtree" json:"willSkipSubtree"`
+	WillSkipAncestors bool   `codec:"willSkipAncestors" json:"willSkipAncestors"`
+}
+
+func (o TeamTreeError) DeepCopy() TeamTreeError {
+	return TeamTreeError{
+		Message:           o.Message,
+		WillSkipSubtree:   o.WillSkipSubtree,
+		WillSkipAncestors: o.WillSkipAncestors,
+	}
+}
+
+type TeamTreeMembershipResult struct {
+	S__     TeamTreeMembershipStatus `codec:"s" json:"s"`
+	Ok__    *TeamTreeMembershipValue `codec:"ok,omitempty" json:"ok,omitempty"`
+	Error__ *TeamTreeError           `codec:"error,omitempty" json:"error,omitempty"`
+}
+
+func (o *TeamTreeMembershipResult) S() (ret TeamTreeMembershipStatus, err error) {
+	switch o.S__ {
+	case TeamTreeMembershipStatus_OK:
+		if o.Ok__ == nil {
+			err = errors.New("unexpected nil value for Ok__")
+			return ret, err
+		}
+	case TeamTreeMembershipStatus_ERROR:
+		if o.Error__ == nil {
+			err = errors.New("unexpected nil value for Error__")
+			return ret, err
+		}
+	}
+	return o.S__, nil
+}
+
+func (o TeamTreeMembershipResult) Ok() (res TeamTreeMembershipValue) {
+	if o.S__ != TeamTreeMembershipStatus_OK {
+		panic("wrong case accessed")
+	}
+	if o.Ok__ == nil {
+		return
+	}
+	return *o.Ok__
+}
+
+func (o TeamTreeMembershipResult) Error() (res TeamTreeError) {
+	if o.S__ != TeamTreeMembershipStatus_ERROR {
+		panic("wrong case accessed")
+	}
+	if o.Error__ == nil {
+		return
+	}
+	return *o.Error__
+}
+
+func NewTeamTreeMembershipResultWithOk(v TeamTreeMembershipValue) TeamTreeMembershipResult {
+	return TeamTreeMembershipResult{
+		S__:  TeamTreeMembershipStatus_OK,
+		Ok__: &v,
+	}
+}
+
+func NewTeamTreeMembershipResultWithError(v TeamTreeError) TeamTreeMembershipResult {
+	return TeamTreeMembershipResult{
+		S__:     TeamTreeMembershipStatus_ERROR,
+		Error__: &v,
+	}
+}
+
+func NewTeamTreeMembershipResultWithHidden() TeamTreeMembershipResult {
+	return TeamTreeMembershipResult{
+		S__: TeamTreeMembershipStatus_HIDDEN,
+	}
+}
+
+func (o TeamTreeMembershipResult) DeepCopy() TeamTreeMembershipResult {
+	return TeamTreeMembershipResult{
+		S__: o.S__.DeepCopy(),
+		Ok__: (func(x *TeamTreeMembershipValue) *TeamTreeMembershipValue {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Ok__),
+		Error__: (func(x *TeamTreeError) *TeamTreeError {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Error__),
+	}
+}
+
+type TeamTreeMembership struct {
+	TeamName       string                   `codec:"teamName" json:"teamName"`
+	Result         TeamTreeMembershipResult `codec:"result" json:"result"`
+	TargetTeamID   TeamID                   `codec:"targetTeamID" json:"targetTeamID"`
+	TargetUsername string                   `codec:"targetUsername" json:"targetUsername"`
+	Guid           int                      `codec:"guid" json:"guid"`
+}
+
+func (o TeamTreeMembership) DeepCopy() TeamTreeMembership {
+	return TeamTreeMembership{
+		TeamName:       o.TeamName,
+		Result:         o.Result.DeepCopy(),
+		TargetTeamID:   o.TargetTeamID.DeepCopy(),
+		TargetUsername: o.TargetUsername,
+		Guid:           o.Guid,
+	}
+}
+
+type TeamTreeMembershipsDoneResult struct {
+	ExpectedCount  int    `codec:"expectedCount" json:"expectedCount"`
+	TargetTeamID   TeamID `codec:"targetTeamID" json:"targetTeamID"`
+	TargetUsername string `codec:"targetUsername" json:"targetUsername"`
+	Guid           int    `codec:"guid" json:"guid"`
+}
+
+func (o TeamTreeMembershipsDoneResult) DeepCopy() TeamTreeMembershipsDoneResult {
+	return TeamTreeMembershipsDoneResult{
+		ExpectedCount:  o.ExpectedCount,
+		TargetTeamID:   o.TargetTeamID.DeepCopy(),
+		TargetUsername: o.TargetUsername,
+		Guid:           o.Guid,
+	}
+}
+
+type TeamTreeInitial struct {
+	Guid int `codec:"guid" json:"guid"`
+}
+
+func (o TeamTreeInitial) DeepCopy() TeamTreeInitial {
+	return TeamTreeInitial{
+		Guid: o.Guid,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams_ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams_ui.go
index 2c713aa6..76e51033 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams_ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teams_ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/teams_ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teamsearch.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teamsearch.go
new file mode 100644
index 00000000..2cf5ab7e
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/teamsearch.go
@@ -0,0 +1,85 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/keybase1/teamsearch.avdl
+
+package keybase1
+
+type TeamSearchItem struct {
+	Id          TeamID  `codec:"id" json:"id"`
+	Name        string  `codec:"name" json:"name"`
+	Description *string `codec:"description,omitempty" json:"description,omitempty"`
+	MemberCount int     `codec:"memberCount" json:"memberCount"`
+	LastActive  Time    `codec:"lastActive" json:"lastActive"`
+	IsDemoted   bool    `codec:"isDemoted" json:"isDemoted"`
+	InTeam      bool    `codec:"inTeam" json:"inTeam"`
+}
+
+func (o TeamSearchItem) DeepCopy() TeamSearchItem {
+	return TeamSearchItem{
+		Id:   o.Id.DeepCopy(),
+		Name: o.Name,
+		Description: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.Description),
+		MemberCount: o.MemberCount,
+		LastActive:  o.LastActive.DeepCopy(),
+		IsDemoted:   o.IsDemoted,
+		InTeam:      o.InTeam,
+	}
+}
+
+type TeamSearchExport struct {
+	Items     map[TeamID]TeamSearchItem `codec:"items" json:"items"`
+	Suggested []TeamID                  `codec:"suggested" json:"suggested"`
+}
+
+func (o TeamSearchExport) DeepCopy() TeamSearchExport {
+	return TeamSearchExport{
+		Items: (func(x map[TeamID]TeamSearchItem) map[TeamID]TeamSearchItem {
+			if x == nil {
+				return nil
+			}
+			ret := make(map[TeamID]TeamSearchItem, len(x))
+			for k, v := range x {
+				kCopy := k.DeepCopy()
+				vCopy := v.DeepCopy()
+				ret[kCopy] = vCopy
+			}
+			return ret
+		})(o.Items),
+		Suggested: (func(x []TeamID) []TeamID {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TeamID, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Suggested),
+	}
+}
+
+type TeamSearchRes struct {
+	Results []TeamSearchItem `codec:"results" json:"results"`
+}
+
+func (o TeamSearchRes) DeepCopy() TeamSearchRes {
+	return TeamSearchRes{
+		Results: (func(x []TeamSearchItem) []TeamSearchItem {
+			if x == nil {
+				return nil
+			}
+			ret := make([]TeamSearchItem, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Results),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/test.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/test.go
index d8d6dd8a..e8944f06 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/test.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/test.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/test.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf.go
index ec803243..e6b00761 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/tlf.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf_keys.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf_keys.go
index 2aa0ee50..02c74db4 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf_keys.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/tlf_keys.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/tlf_keys.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/track.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/track.go
index 23ce1678..e1e3368b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/track.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/track.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/track.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ui.go
index 7eb6201c..f86a263b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/ui.avdl
 
 package keybase1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/upk.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/upk.go
index 3148b115..134ee85b 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/upk.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/upk.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/upk.avdl
 
 package keybase1
@@ -127,8 +127,8 @@ func (o SignatureMetadata) DeepCopy() SignatureMetadata {
 		SigningKID:              o.SigningKID.DeepCopy(),
 		PrevMerkleRootSigned:    o.PrevMerkleRootSigned.DeepCopy(),
 		FirstAppearedUnverified: o.FirstAppearedUnverified.DeepCopy(),
-		Time:                    o.Time.DeepCopy(),
-		SigChainLocation:        o.SigChainLocation.DeepCopy(),
+		Time:             o.Time.DeepCopy(),
+		SigChainLocation: o.SigChainLocation.DeepCopy(),
 	}
 }
 
@@ -165,7 +165,7 @@ type PublicKeyV2NaCl struct {
 	Parent            *KID            `codec:"parent,omitempty" json:"parent,omitempty"`
 	DeviceID          DeviceID        `codec:"deviceID" json:"deviceID"`
 	DeviceDescription string          `codec:"deviceDescription" json:"deviceDescription"`
-	DeviceType        string          `codec:"deviceType" json:"deviceType"`
+	DeviceType        DeviceTypeV2    `codec:"deviceType" json:"deviceType"`
 }
 
 func (o PublicKeyV2NaCl) DeepCopy() PublicKeyV2NaCl {
@@ -180,7 +180,7 @@ func (o PublicKeyV2NaCl) DeepCopy() PublicKeyV2NaCl {
 		})(o.Parent),
 		DeviceID:          o.DeviceID.DeepCopy(),
 		DeviceDescription: o.DeviceDescription,
-		DeviceType:        o.DeviceType,
+		DeviceType:        o.DeviceType.DeepCopy(),
 	}
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/user.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/user.go
index 47b3ab9b..bd1cde4d 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/user.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/user.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/user.avdl
 
 package keybase1
@@ -88,28 +88,48 @@ func (o Proofs) DeepCopy() Proofs {
 }
 
 type UserSummary struct {
-	Uid          UID    `codec:"uid" json:"uid"`
-	Username     string `codec:"username" json:"username"`
-	Thumbnail    string `codec:"thumbnail" json:"thumbnail"`
-	IdVersion    int    `codec:"idVersion" json:"idVersion"`
-	FullName     string `codec:"fullName" json:"fullName"`
-	Bio          string `codec:"bio" json:"bio"`
-	Proofs       Proofs `codec:"proofs" json:"proofs"`
-	SigIDDisplay string `codec:"sigIDDisplay" json:"sigIDDisplay"`
-	TrackTime    Time   `codec:"trackTime" json:"trackTime"`
+	Uid      UID     `codec:"uid" json:"uid"`
+	Username string  `codec:"username" json:"username"`
+	FullName string  `codec:"fullName" json:"fullName"`
+	LinkID   *LinkID `codec:"linkID,omitempty" json:"linkID,omitempty"`
 }
 
 func (o UserSummary) DeepCopy() UserSummary {
 	return UserSummary{
-		Uid:          o.Uid.DeepCopy(),
-		Username:     o.Username,
-		Thumbnail:    o.Thumbnail,
-		IdVersion:    o.IdVersion,
-		FullName:     o.FullName,
-		Bio:          o.Bio,
-		Proofs:       o.Proofs.DeepCopy(),
-		SigIDDisplay: o.SigIDDisplay,
-		TrackTime:    o.TrackTime.DeepCopy(),
+		Uid:      o.Uid.DeepCopy(),
+		Username: o.Username,
+		FullName: o.FullName,
+		LinkID: (func(x *LinkID) *LinkID {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.LinkID),
+	}
+}
+
+type UserSummarySet struct {
+	Users   []UserSummary `codec:"users" json:"users"`
+	Time    Time          `codec:"time" json:"time"`
+	Version int           `codec:"version" json:"version"`
+}
+
+func (o UserSummarySet) DeepCopy() UserSummarySet {
+	return UserSummarySet{
+		Users: (func(x []UserSummary) []UserSummary {
+			if x == nil {
+				return nil
+			}
+			ret := make([]UserSummary, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Users),
+		Time:    o.Time.DeepCopy(),
+		Version: o.Version,
 	}
 }
 
@@ -169,50 +189,6 @@ func (o UserSettings) DeepCopy() UserSettings {
 	}
 }
 
-type UserSummary2 struct {
-	Uid        UID    `codec:"uid" json:"uid"`
-	Username   string `codec:"username" json:"username"`
-	Thumbnail  string `codec:"thumbnail" json:"thumbnail"`
-	FullName   string `codec:"fullName" json:"fullName"`
-	IsFollower bool   `codec:"isFollower" json:"isFollower"`
-	IsFollowee bool   `codec:"isFollowee" json:"isFollowee"`
-}
-
-func (o UserSummary2) DeepCopy() UserSummary2 {
-	return UserSummary2{
-		Uid:        o.Uid.DeepCopy(),
-		Username:   o.Username,
-		Thumbnail:  o.Thumbnail,
-		FullName:   o.FullName,
-		IsFollower: o.IsFollower,
-		IsFollowee: o.IsFollowee,
-	}
-}
-
-type UserSummary2Set struct {
-	Users   []UserSummary2 `codec:"users" json:"users"`
-	Time    Time           `codec:"time" json:"time"`
-	Version int            `codec:"version" json:"version"`
-}
-
-func (o UserSummary2Set) DeepCopy() UserSummary2Set {
-	return UserSummary2Set{
-		Users: (func(x []UserSummary2) []UserSummary2 {
-			if x == nil {
-				return nil
-			}
-			ret := make([]UserSummary2, len(x))
-			for i, v := range x {
-				vCopy := v.DeepCopy()
-				ret[i] = vCopy
-			}
-			return ret
-		})(o.Users),
-		Time:    o.Time.DeepCopy(),
-		Version: o.Version,
-	}
-}
-
 type InterestingPerson struct {
 	Uid        UID               `codec:"uid" json:"uid"`
 	Username   string            `codec:"username" json:"username"`
@@ -263,15 +239,16 @@ func (o ProofSuggestionsRes) DeepCopy() ProofSuggestionsRes {
 }
 
 type ProofSuggestion struct {
-	Key              string             `codec:"key" json:"key"`
-	BelowFold        bool               `codec:"belowFold" json:"belowFold"`
-	ProfileText      string             `codec:"profileText" json:"profileText"`
-	ProfileIcon      []SizedImage       `codec:"profileIcon" json:"profileIcon"`
-	ProfileIconWhite []SizedImage       `codec:"profileIconWhite" json:"profileIconWhite"`
-	PickerText       string             `codec:"pickerText" json:"pickerText"`
-	PickerSubtext    string             `codec:"pickerSubtext" json:"pickerSubtext"`
-	PickerIcon       []SizedImage       `codec:"pickerIcon" json:"pickerIcon"`
-	Metas            []Identify3RowMeta `codec:"metas" json:"metas"`
+	Key                 string             `codec:"key" json:"key"`
+	BelowFold           bool               `codec:"belowFold" json:"belowFold"`
+	ProfileText         string             `codec:"profileText" json:"profileText"`
+	ProfileIcon         []SizedImage       `codec:"profileIcon" json:"profileIcon"`
+	ProfileIconDarkmode []SizedImage       `codec:"profileIconDarkmode" json:"profileIconDarkmode"`
+	PickerText          string             `codec:"pickerText" json:"pickerText"`
+	PickerSubtext       string             `codec:"pickerSubtext" json:"pickerSubtext"`
+	PickerIcon          []SizedImage       `codec:"pickerIcon" json:"pickerIcon"`
+	PickerIconDarkmode  []SizedImage       `codec:"pickerIconDarkmode" json:"pickerIconDarkmode"`
+	Metas               []Identify3RowMeta `codec:"metas" json:"metas"`
 }
 
 func (o ProofSuggestion) DeepCopy() ProofSuggestion {
@@ -290,7 +267,7 @@ func (o ProofSuggestion) DeepCopy() ProofSuggestion {
 			}
 			return ret
 		})(o.ProfileIcon),
-		ProfileIconWhite: (func(x []SizedImage) []SizedImage {
+		ProfileIconDarkmode: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
 			}
@@ -300,7 +277,7 @@ func (o ProofSuggestion) DeepCopy() ProofSuggestion {
 				ret[i] = vCopy
 			}
 			return ret
-		})(o.ProfileIconWhite),
+		})(o.ProfileIconDarkmode),
 		PickerText:    o.PickerText,
 		PickerSubtext: o.PickerSubtext,
 		PickerIcon: (func(x []SizedImage) []SizedImage {
@@ -314,6 +291,17 @@ func (o ProofSuggestion) DeepCopy() ProofSuggestion {
 			}
 			return ret
 		})(o.PickerIcon),
+		PickerIconDarkmode: (func(x []SizedImage) []SizedImage {
+			if x == nil {
+				return nil
+			}
+			ret := make([]SizedImage, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.PickerIconDarkmode),
 		Metas: (func(x []Identify3RowMeta) []Identify3RowMeta {
 			if x == nil {
 				return nil
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/usersearch.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/usersearch.go
index 3c66adf0..cf492935 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/usersearch.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/usersearch.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/keybase1/usersearch.avdl
 
 package keybase1
@@ -167,15 +167,16 @@ func (o APIUserSearchResult) DeepCopy() APIUserSearchResult {
 }
 
 type NonUserDetails struct {
-	IsNonUser      bool                  `codec:"isNonUser" json:"isNonUser"`
-	AssertionValue string                `codec:"assertionValue" json:"assertionValue"`
-	AssertionKey   string                `codec:"assertionKey" json:"assertionKey"`
-	Description    string                `codec:"description" json:"description"`
-	Contact        *ProcessedContact     `codec:"contact,omitempty" json:"contact,omitempty"`
-	Service        *APIUserServiceResult `codec:"service,omitempty" json:"service,omitempty"`
-	SiteIcon       []SizedImage          `codec:"siteIcon" json:"siteIcon"`
-	SiteIconFull   []SizedImage          `codec:"siteIconFull" json:"siteIconFull"`
-	SiteIconWhite  []SizedImage          `codec:"siteIconWhite" json:"siteIconWhite"`
+	IsNonUser            bool                  `codec:"isNonUser" json:"isNonUser"`
+	AssertionValue       string                `codec:"assertionValue" json:"assertionValue"`
+	AssertionKey         string                `codec:"assertionKey" json:"assertionKey"`
+	Description          string                `codec:"description" json:"description"`
+	Contact              *ProcessedContact     `codec:"contact,omitempty" json:"contact,omitempty"`
+	Service              *APIUserServiceResult `codec:"service,omitempty" json:"service,omitempty"`
+	SiteIcon             []SizedImage          `codec:"siteIcon" json:"siteIcon"`
+	SiteIconDarkmode     []SizedImage          `codec:"siteIconDarkmode" json:"siteIconDarkmode"`
+	SiteIconFull         []SizedImage          `codec:"siteIconFull" json:"siteIconFull"`
+	SiteIconFullDarkmode []SizedImage          `codec:"siteIconFullDarkmode" json:"siteIconFullDarkmode"`
 }
 
 func (o NonUserDetails) DeepCopy() NonUserDetails {
@@ -209,6 +210,17 @@ func (o NonUserDetails) DeepCopy() NonUserDetails {
 			}
 			return ret
 		})(o.SiteIcon),
+		SiteIconDarkmode: (func(x []SizedImage) []SizedImage {
+			if x == nil {
+				return nil
+			}
+			ret := make([]SizedImage, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.SiteIconDarkmode),
 		SiteIconFull: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
@@ -220,7 +232,7 @@ func (o NonUserDetails) DeepCopy() NonUserDetails {
 			}
 			return ret
 		})(o.SiteIconFull),
-		SiteIconWhite: (func(x []SizedImage) []SizedImage {
+		SiteIconFullDarkmode: (func(x []SizedImage) []SizedImage {
 			if x == nil {
 				return nil
 			}
@@ -230,6 +242,28 @@ func (o NonUserDetails) DeepCopy() NonUserDetails {
 				ret[i] = vCopy
 			}
 			return ret
-		})(o.SiteIconWhite),
+		})(o.SiteIconFullDarkmode),
+	}
+}
+
+type EmailOrPhoneNumberSearchResult struct {
+	Input          string `codec:"input" json:"input"`
+	Assertion      string `codec:"assertion" json:"assertion"`
+	AssertionValue string `codec:"assertionValue" json:"assertionValue"`
+	AssertionKey   string `codec:"assertionKey" json:"assertionKey"`
+	FoundUser      bool   `codec:"foundUser" json:"foundUser"`
+	Username       string `codec:"username" json:"username"`
+	FullName       string `codec:"fullName" json:"fullName"`
+}
+
+func (o EmailOrPhoneNumberSearchResult) DeepCopy() EmailOrPhoneNumberSearchResult {
+	return EmailOrPhoneNumberSearchResult{
+		Input:          o.Input,
+		Assertion:      o.Assertion,
+		AssertionValue: o.AssertionValue,
+		AssertionKey:   o.AssertionKey,
+		FoundUser:      o.FoundUser,
+		Username:       o.Username,
+		FullName:       o.FullName,
 	}
 }
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/wot.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/wot.go
new file mode 100644
index 00000000..694d13b5
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/keybase1/wot.go
@@ -0,0 +1,116 @@
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
+//   Input file: ../client/protocol/avdl/keybase1/wot.avdl
+
+package keybase1
+
+import (
+	"fmt"
+)
+
+type UsernameVerificationType string
+
+func (o UsernameVerificationType) DeepCopy() UsernameVerificationType {
+	return o
+}
+
+type WotProof struct {
+	ProofType ProofType `codec:"proofType" json:"proof_type"`
+	Name      string    `codec:"name" json:"name,omitempty"`
+	Username  string    `codec:"username" json:"username,omitempty"`
+	Protocol  string    `codec:"protocol" json:"protocol,omitempty"`
+	Hostname  string    `codec:"hostname" json:"hostname,omitempty"`
+	Domain    string    `codec:"domain" json:"domain,omitempty"`
+}
+
+func (o WotProof) DeepCopy() WotProof {
+	return WotProof{
+		ProofType: o.ProofType.DeepCopy(),
+		Name:      o.Name,
+		Username:  o.Username,
+		Protocol:  o.Protocol,
+		Hostname:  o.Hostname,
+		Domain:    o.Domain,
+	}
+}
+
+type Confidence struct {
+	UsernameVerifiedVia UsernameVerificationType `codec:"usernameVerifiedVia" json:"username_verified_via,omitempty"`
+	Proofs              []WotProof               `codec:"proofs" json:"proofs,omitempty"`
+	Other               string                   `codec:"other" json:"other,omitempty"`
+}
+
+func (o Confidence) DeepCopy() Confidence {
+	return Confidence{
+		UsernameVerifiedVia: o.UsernameVerifiedVia.DeepCopy(),
+		Proofs: (func(x []WotProof) []WotProof {
+			if x == nil {
+				return nil
+			}
+			ret := make([]WotProof, len(x))
+			for i, v := range x {
+				vCopy := v.DeepCopy()
+				ret[i] = vCopy
+			}
+			return ret
+		})(o.Proofs),
+		Other: o.Other,
+	}
+}
+
+type WotReactionType int
+
+const (
+	WotReactionType_ACCEPT WotReactionType = 0
+	WotReactionType_REJECT WotReactionType = 1
+)
+
+func (o WotReactionType) DeepCopy() WotReactionType { return o }
+
+var WotReactionTypeMap = map[string]WotReactionType{
+	"ACCEPT": 0,
+	"REJECT": 1,
+}
+
+var WotReactionTypeRevMap = map[WotReactionType]string{
+	0: "ACCEPT",
+	1: "REJECT",
+}
+
+func (e WotReactionType) String() string {
+	if v, ok := WotReactionTypeRevMap[e]; ok {
+		return v
+	}
+	return fmt.Sprintf("%v", int(e))
+}
+
+type WotVouch struct {
+	Status          WotStatusType `codec:"status" json:"status"`
+	VouchProof      SigID         `codec:"vouchProof" json:"vouchProof"`
+	Vouchee         UserVersion   `codec:"vouchee" json:"vouchee"`
+	VoucheeUsername string        `codec:"voucheeUsername" json:"voucheeUsername"`
+	Voucher         UserVersion   `codec:"voucher" json:"voucher"`
+	VoucherUsername string        `codec:"voucherUsername" json:"voucherUsername"`
+	VouchText       string        `codec:"vouchText" json:"vouchText"`
+	VouchedAt       Time          `codec:"vouchedAt" json:"vouchedAt"`
+	Confidence      *Confidence   `codec:"confidence,omitempty" json:"confidence,omitempty"`
+}
+
+func (o WotVouch) DeepCopy() WotVouch {
+	return WotVouch{
+		Status:          o.Status.DeepCopy(),
+		VouchProof:      o.VouchProof.DeepCopy(),
+		Vouchee:         o.Vouchee.DeepCopy(),
+		VoucheeUsername: o.VoucheeUsername,
+		Voucher:         o.Voucher.DeepCopy(),
+		VoucherUsername: o.VoucherUsername,
+		VouchText:       o.VouchText,
+		VouchedAt:       o.VouchedAt.DeepCopy(),
+		Confidence: (func(x *Confidence) *Confidence {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x).DeepCopy()
+			return &tmp
+		})(o.Confidence),
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/bundle.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/bundle.go
index d5102ad9..ab08a284 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/bundle.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/bundle.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/bundle.avdl
 
 package stellar1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/common.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/common.go
index cf49a1d8..03ddc409 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/common.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/common.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/common.avdl
 
 package stellar1
@@ -86,6 +86,7 @@ type Asset struct {
 	AuthEndpoint       string `codec:"authEndpoint" json:"authEndpoint"`
 	DepositReqAuth     bool   `codec:"depositReqAuth" json:"depositReqAuth"`
 	WithdrawReqAuth    bool   `codec:"withdrawReqAuth" json:"withdrawReqAuth"`
+	UseSep24           bool   `codec:"useSep24" json:"useSep24"`
 }
 
 func (o Asset) DeepCopy() Asset {
@@ -107,6 +108,7 @@ func (o Asset) DeepCopy() Asset {
 		AuthEndpoint:       o.AuthEndpoint,
 		DepositReqAuth:     o.DepositReqAuth,
 		WithdrawReqAuth:    o.WithdrawReqAuth,
+		UseSep24:           o.UseSep24,
 	}
 }
 
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/gregor.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/gregor.go
index bcdf8592..0928f03d 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/gregor.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/gregor.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/gregor.avdl
 
 package stellar1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/local.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/local.go
index ec474d28..fb858852 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/local.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/local.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/local.avdl
 
 package stellar1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/notify.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/notify.go
index f095bf00..ef8e4b11 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/notify.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/notify.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/notify.avdl
 
 package stellar1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/remote.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/remote.go
index 798506a2..0ef09fba 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/remote.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/remote.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/remote.avdl
 
 package stellar1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/ui.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/ui.go
index 8decce76..dfb0d7c5 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/ui.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/types/stellar1/ui.go
@@ -1,4 +1,4 @@
-// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler)
+// Auto-generated to Go types using avdl-compiler v1.4.8 (https://github.com/keybase/node-avdl-compiler)
 //   Input file: ../client/protocol/avdl/stellar1/ui.avdl
 
 package stellar1
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/util.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/util.go
new file mode 100644
index 00000000..91cf5e33
--- /dev/null
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/util.go
@@ -0,0 +1,38 @@
+package kbchat
+
+import (
+	"fmt"
+	"log"
+	"time"
+)
+
+func ErrToOK(err *error) string {
+	if err == nil || *err == nil {
+		return "ok"
+	}
+	return fmt.Sprintf("ERROR: %v", *err)
+}
+
+type DebugOutput struct {
+	name string
+}
+
+func NewDebugOutput(name string) *DebugOutput {
+	return &DebugOutput{
+		name: name,
+	}
+}
+
+func (d *DebugOutput) Debug(format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+	log.Printf("%s: %s\n", d.name, msg)
+}
+
+func (d *DebugOutput) Trace(err *error, format string, args ...interface{}) func() {
+	msg := fmt.Sprintf(format, args...)
+	start := time.Now()
+	log.Printf("+ %s: %s\n", d.name, msg)
+	return func() {
+		log.Printf("- %s: %s -> %s [time=%v]\n", d.name, msg, ErrToOK(err), time.Since(start))
+	}
+}
diff --git a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/wallet.go b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/wallet.go
index fb9cfb31..1ced65e4 100644
--- a/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/wallet.go
+++ b/vendor/github.com/keybase/go-keybase-chat-bot/kbchat/wallet.go
@@ -17,7 +17,11 @@ func (a *API) GetWalletTxDetails(txID string) (wOut WalletOutput, err error) {
 	a.Lock()
 	defer a.Unlock()
 
-	apiInput := fmt.Sprintf(`{"method": "details", "params": {"options": {"txid": "%s"}}}`, txID)
+	txIDEscaped, err := json.Marshal(txID)
+	if err != nil {
+		return wOut, err
+	}
+	apiInput := fmt.Sprintf(`{"method": "details", "params": {"options": {"txid": %s}}}`, txIDEscaped)
 	cmd := a.runOpts.Command("wallet", "api")
 	cmd.Stdin = strings.NewReader(apiInput)
 	var out bytes.Buffer